diff --git a/Libgomp_prealloc_lazy_task/libgomp.tar.xz b/Libgomp_prealloc_lazy_task/libgomp.tar.xz new file mode 100644 index 0000000000000000000000000000000000000000..89e15d7b05f06afcc6062de22f7d64657dcbb135 Binary files /dev/null and b/Libgomp_prealloc_lazy_task/libgomp.tar.xz differ diff --git a/README.md b/README.md deleted file mode 100644 index ae4687b75fd6075acd3bee1420938f5fbcfc4be2..0000000000000000000000000000000000000000 --- a/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# mercurium - diff --git a/libgomp_taskgraph/#task.c# b/libgomp_taskgraph/#task.c# new file mode 100644 index 0000000000000000000000000000000000000000..24b75c57c17aee20f4d9d89ad8d93555e5d51684 --- /dev/null +++ b/libgomp_taskgraph/#task.c# @@ -0,0 +1,2469 @@ +/* Copyright (C) 2007-2017 Free Software Foundation, Inc. + Contributed by Richard Henderson . + + This file is part of the GNU Offloading and Multi Processing Library + (libgomp). + + Libgomp is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU General Public License for + more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . */ + +/* This file handles the maintainence of tasks in response to task + creation and termination. */ + +#include "libgomp.h" +#include +#include + +#include + +// time measurements +#include + +#include "gomp-constants.h" + +typedef struct gomp_task_depend_entry *hash_entry_type; + +static inline void * +htab_alloc (size_t size) +{ + return gomp_malloc (size); +} + +static inline void +htab_free (void *ptr) +{ + free (ptr); +} + +#include "hashtab.h" + +static inline hashval_t +htab_hash (hash_entry_type element) +{ + return hash_pointer (element->addr); +} + +static inline bool +htab_eq (hash_entry_type x, hash_entry_type y) +{ + return x->addr == y->addr; +} + +/* Create a new task data structure. */ + +void +gomp_init_task (struct gomp_task *task, struct gomp_task *parent_task, + struct gomp_task_icv *prev_icv) +{ + /* It would seem that using memset here would be a win, but it turns + out that partially filling gomp_task allows us to keep the + overhead of task creation low. In the nqueens-1.c test, for a + sufficiently large N, we drop the overhead from 5-6% to 1%. + + Note, the nqueens-1.c test in serial mode is a good test to + benchmark the overhead of creating tasks as there are millions of + tiny tasks created that all run undeferred. */ + task->parent = parent_task; + task->icv = *prev_icv; + task->kind = GOMP_TASK_IMPLICIT; + task->taskwait = NULL; + task->in_tied_task = false; + task->final_task = false; + task->copy_ctors_done = false; + task->parent_depends_on = false; + priority_queue_init (&task->children_queue); + task->taskgroup = NULL; + task->dependers = NULL; + task->depend_hash = NULL; + task->tdg = NULL; + task->depend_count = 0; +} + +/* Clean up a task, after completing it. */ + +void +gomp_end_task (void) +{ + struct gomp_thread *thr = gomp_thread (); + struct gomp_task *task = thr->task; + + gomp_finish_task (task); + thr->task = task->parent; +} + +/* Clear the parent field of every task in LIST. */ + +static inline void +gomp_clear_parent_in_list (struct priority_list *list) +{ + struct priority_node *p = list->tasks; + if (p) + do + { + priority_node_to_task (PQ_CHILDREN, p)->parent = NULL; + p = p->next; + } + while (p != list->tasks); +} + +/* Splay tree version of gomp_clear_parent_in_list. + + Clear the parent field of every task in NODE within SP, and free + the node when done. */ + +static void +gomp_clear_parent_in_tree (prio_splay_tree sp, prio_splay_tree_node node) +{ + if (!node) + return; + prio_splay_tree_node left = node->left, right = node->right; + gomp_clear_parent_in_list (&node->key.l); +#if _LIBGOMP_CHECKING_ + memset (node, 0xaf, sizeof (*node)); +#endif + /* No need to remove the node from the tree. We're nuking + everything, so just free the nodes and our caller can clear the + entire splay tree. */ + free (node); + gomp_clear_parent_in_tree (sp, left); + gomp_clear_parent_in_tree (sp, right); +} + +/* Clear the parent field of every task in Q and remove every task + from Q. */ + +static inline void +gomp_clear_parent (struct priority_queue *q) +{ + if (priority_queue_multi_p (q)) + { + gomp_clear_parent_in_tree (&q->t, q->t.root); + /* All the nodes have been cleared in gomp_clear_parent_in_tree. + No need to remove anything. We can just nuke everything. */ + q->t.root = NULL; + } + else + gomp_clear_parent_in_list (&q->l); +} + +/* Helper function for GOMP_task and gomp_create_target_task. + + For a TASK with in/out dependencies, fill in the various dependency + queues. PARENT is the parent of said task. DEPEND is as in + GOMP_task. */ + +static void +gomp_task_handle_depend (struct gomp_task *task, struct gomp_task *parent, + void **depend) +{ + size_t ndepend = (uintptr_t) depend[0]; + size_t nout = (uintptr_t) depend[1]; + size_t i; + hash_entry_type ent; + + task->depend_count = ndepend; + task->num_dependees = 0; + if (parent->depend_hash == NULL) + parent->depend_hash = htab_create (2 * ndepend > 12 ? 2 * ndepend : 12); + for (i = 0; i < ndepend; i++) + { + task->depend[i].addr = depend[2 + i]; + task->depend[i].next = NULL; + task->depend[i].prev = NULL; + task->depend[i].task = task; + task->depend[i].is_in = i >= nout; + task->depend[i].redundant = false; + task->depend[i].redundant_out = false; + + hash_entry_type *slot = htab_find_slot (&parent->depend_hash, + &task->depend[i], INSERT); + hash_entry_type out = NULL, last = NULL; + if (*slot) + { + /* If multiple depends on the same task are the same, all but the + first one are redundant. As inout/out come first, if any of them + is inout/out, it will win, which is the right semantics. */ + if ((*slot)->task == task) + { + task->depend[i].redundant = true; + continue; + } + for (ent = *slot; ent; ent = ent->next) + { + if (ent->redundant_out) + break; + + last = ent; + + /* depend(in:...) doesn't depend on earlier depend(in:...). */ + if (i >= nout && ent->is_in) + continue; + + if (!ent->is_in) + out = ent; + + struct gomp_task *tsk = ent->task; + if (tsk->dependers == NULL) + { + tsk->dependers + = gomp_malloc (sizeof (struct gomp_dependers_vec) + + 6 * sizeof (struct gomp_task *)); + tsk->dependers->n_elem = 1; + tsk->dependers->allocated = 6; + tsk->dependers->elem[0] = task; + task->num_dependees++; + continue; + } + /* We already have some other dependency on tsk from earlier + depend clause. */ + else if (tsk->dependers->n_elem + && (tsk->dependers->elem[tsk->dependers->n_elem - 1] + == task)) + continue; + else if (tsk->dependers->n_elem == tsk->dependers->allocated) + { + tsk->dependers->allocated + = tsk->dependers->allocated * 2 + 2; + tsk->dependers + = gomp_realloc (tsk->dependers, + sizeof (struct gomp_dependers_vec) + + (tsk->dependers->allocated + * sizeof (struct gomp_task *))); + } + tsk->dependers->elem[tsk->dependers->n_elem++] = task; + task->num_dependees++; + } + task->depend[i].next = *slot; + (*slot)->prev = &task->depend[i]; + } + *slot = &task->depend[i]; + + /* There is no need to store more than one depend({,in}out:) task per + address in the hash table chain for the purpose of creation of + deferred tasks, because each out depends on all earlier outs, thus it + is enough to record just the last depend({,in}out:). For depend(in:), + we need to keep all of the previous ones not terminated yet, because + a later depend({,in}out:) might need to depend on all of them. So, if + the new task's clause is depend({,in}out:), we know there is at most + one other depend({,in}out:) clause in the list (out). For + non-deferred tasks we want to see all outs, so they are moved to the + end of the chain, after first redundant_out entry all following + entries should be redundant_out. */ + if (!task->depend[i].is_in && out) + { + if (out != last) + { + out->next->prev = out->prev; + out->prev->next = out->next; + out->next = last->next; + out->prev = last; + last->next = out; + if (out->next) + out->next->prev = out; + } + out->redundant_out = true; + } + } +} + +/* function has two different behaviours, static tdg or dynamic tdg */ +void GOMP_task (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *), + long arg_size, long arg_align, bool if_clause, unsigned flags, + void **depend, int priority, unsigned int pragma_id, + unsigned int instance_id, unsigned int GOMP_TDG_ENUM) +{ + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + +#ifdef HAVE_BROKEN_POSIX_SEMAPHORES + /* If pthread_mutex_* is used for omp_*lock*, then each task must be + tied to one thread all the time. This means UNTIED tasks must be + tied and if CPYFN is non-NULL IF(0) must be forced, as CPYFN + might be running on different thread than FN. */ + if (cpyfn) + if_clause = false; + flags &= ~GOMP_TASK_FLAG_UNTIED; +#endif + + /* If parallel or taskgroup has been cancelled, don't start new tasks. */ + if (team + && (gomp_team_barrier_cancelled (&team->barrier) + || (thr->task->taskgroup && thr->task->taskgroup->cancelled))) + return; + + // gomp_max_task_priority_var = 0 by default, either change it in env.c or + // declare the environment variable OMP_MAX_TASK_PRIORITY > 0 + if ((flags & GOMP_TASK_FLAG_PRIORITY) == 0) + priority = 0; + else if (priority > gomp_max_task_priority_var) + priority = gomp_max_task_priority_var; + + + + if (!if_clause || team == NULL + || (thr->task && thr->task->final_task) + || team->task_count > 64 * team->nthreads) // chenle: cases where the task is undeferred + { + struct gomp_task task; + + /* If there are depend clauses and earlier deferred sibling tasks + with depend clauses, check if there isn't a dependency. If there + is, we need to wait for them. There is no need to handle + depend clauses for non-deferred tasks other than this, because + the parent task is suspended until the child task finishes and thus + it can't start further child tasks. */ + + // TODO dependency is handled by TDG + if ((flags & GOMP_TASK_FLAG_DEPEND) && thr->task && thr->task->depend_hash) + gomp_task_maybe_wait_for_dependencies (depend); + + + gomp_init_task (&task, thr->task, gomp_icv (false)); + task.kind = GOMP_TASK_UNDEFERRED; + task.final_task = (thr->task && thr->task->final_task) + || (flags & GOMP_TASK_FLAG_FINAL); + task.priority = priority; + if (thr->task) + { + task.in_tied_task = thr->task->in_tied_task; + task.taskgroup = thr->task->taskgroup; + } + thr->task = &task; + if (__builtin_expect (cpyfn != NULL, 0)) + { + char buf[arg_size + arg_align - 1]; + char *arg = (char *) (((uintptr_t) buf + arg_align - 1) + & ~(uintptr_t) (arg_align - 1)); + cpyfn (arg, data); + fn (arg); + } + else + fn (data); + /* Access to "children" is normally done inside a task_lock + mutex region, but the only way this particular task.children + can be set is if this thread's task work function (fn) + creates children. So since the setter is *this* thread, we + need no barriers here when testing for non-NULL. We can have + task.children set by the current thread then changed by a + child thread, but seeing a stale non-NULL value is not a + problem. Once past the task_lock acquisition, this thread + will see the real value of task.children. */ + if (!priority_queue_empty_p (&task.children_queue, MEMMODEL_RELAXED)) + { + gomp_mutex_lock (&team->task_lock); + gomp_clear_parent (&task.children_queue); + gomp_mutex_unlock (&team->task_lock); + } + gomp_end_task (); + } + else + { + char *arg; + bool do_wake; + if (GOMP_TDG_ENUM == GOMP_STATIC_TDG) + { + struct gomp_tdg_node *tdg = gomp_get_tdg(instance_id); + + struct gomp_tdg_task *tdg_task = gomp_malloc (sizeof (struct gomp_tdg_task) + arg_size + arg_align - 1); + + arg = (char *) (((uintptr_t) (tdg_task + 1) + arg_align - 1) + & ~(uintptr_t) (arg_align - 1)); + + // not needed since mercurium always gives 0? + if (cpyfn) + { + cpyfn (arg, data); + //task->copy_ctors_done = true; // tdg_task does not contain this attribute + } + + memcpy (arg, data, arg_size); + + + tdg_task->tdg = tdg; + tdg_task->priority = priority; + tdg_task->parent_depends_on = false; // #TODO only false now, to set to true if parent_depends_on, but in this case, dependency handled by TDG? + tdg_task->kind = GOMP_TASK_WAITING; + tdg_task->in_tied_task = false; + tdg_task->fn = fn; + tdg_task->fn_data = arg; + //task->final_task = (flags & GOMP_TASK_FLAG_FINAL) >> 1; + + gomp_mutex_lock (&team->task_lock); + + // update tdg->task and tdg->cnt + gomp_update_tdg(tdg_task, tdg); + + if(gomp_tdg_get_unresolved_dependencies(tdg) > 0) + { + /* if any input dependencies not solved yet, we are done for now */ + gomp_mutex_unlock (&team->task_lock); + return; + } + + priority_queue_gen_insert (PQ_TEAM, &team->task_queue, + (union task_union_t *)tdg_task, priority, + PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + tdg_task->parent_depends_on, + GOMP_STATIC_TDG); + + /* priority_queue_tdg_insert (PQ_TEAM, &team->task_queue, + tdg_task, priority, + PRIORITY_INSERT_END); */ + ++team->task_count; + ++team->task_queued_count; + gomp_team_barrier_set_task_pending (&team->barrier); + do_wake = team->task_running_count /* + !parent->in_tied_task*/ + < team->nthreads; + + gomp_mutex_unlock (&team->task_lock); + + if (do_wake) + gomp_team_barrier_wake (&team->barrier, 1); + + return; + } + + /* if not TDG */ + struct gomp_task *task; + struct gomp_task *parent = thr->task; + struct gomp_taskgroup *taskgroup = parent->taskgroup; + + size_t depend_size = 0; + if (flags & GOMP_TASK_FLAG_DEPEND) + depend_size = ((uintptr_t) depend[0] + * sizeof (struct gomp_task_depend_entry)); + + task = gomp_malloc (sizeof (*task) + depend_size + + arg_size + arg_align - 1); + arg = (char *) (((uintptr_t) (task + 1) + depend_size + arg_align - 1) + & ~(uintptr_t) (arg_align - 1)); + + gomp_init_task (task, parent, gomp_icv (false)); + // why priority = 0 here, regardless the priority argument in function call + task->priority = priority; + task->kind = GOMP_TASK_UNDEFERRED; + task->in_tied_task = parent->in_tied_task; + task->taskgroup = taskgroup; + thr->task = task; // not necessary? + if (cpyfn) + { + cpyfn (arg, data); + task->copy_ctors_done = true; + } + else + memcpy (arg, data, arg_size); + thr->task = parent; // not necessary? + task->kind = GOMP_TASK_WAITING; + task->fn = fn; + task->fn_data = arg; + task->final_task = (flags & GOMP_TASK_FLAG_FINAL) >> 1; + + gomp_mutex_lock (&team->task_lock); + /* If parallel or taskgroup has been cancelled, don't start new + tasks. */ + if (__builtin_expect ((gomp_team_barrier_cancelled (&team->barrier) + || (taskgroup && taskgroup->cancelled)) + && !task->copy_ctors_done, 0)) + { + gomp_mutex_unlock (&team->task_lock); + gomp_finish_task (task); + free (task); + return; + } + + + if (taskgroup) + taskgroup->num_children++; + + if (depend_size) + { + gomp_task_handle_depend (task, parent, depend); + if (task->num_dependees) + { + /* Tasks that depend on other tasks are not put into the + various waiting queues, so we are done for now. Said + tasks are instead put into the queues via + gomp_task_run_post_handle_dependers() after their + dependencies have been satisfied. After which, they + can be picked up by the various scheduling + points. */ + gomp_mutex_unlock (&team->task_lock); + return; + } + } + + priority_queue_gen_insert (PQ_CHILDREN, &parent->children_queue, + (union task_union_t *)task, priority, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on, + GOMP_DYNAMIC_TDG); + + if (taskgroup) + { + priority_queue_gen_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + (union task_union_t *)task, priority, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on, + GOMP_DYNAMIC_TDG); + } + priority_queue_gen_insert (PQ_TEAM, &team->task_queue, + (union task_union_t *)task, priority, + PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on, + GOMP_DYNAMIC_TDG); + + + // priority_queue_insert (PQ_CHILDREN, &parent->children_queue, + // task, priority, + // PRIORITY_INSERT_BEGIN, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + // if (taskgroup) + // { + // priority_queue_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + // task, priority, + // PRIORITY_INSERT_BEGIN, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + // } + // priority_queue_insert (PQ_TEAM, &team->task_queue, + // task, priority, + // PRIORITY_INSERT_END, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + + ++team->task_count; + ++team->task_queued_count; + gomp_team_barrier_set_task_pending (&team->barrier); + do_wake = team->task_running_count + !parent->in_tied_task + < team->nthreads; + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + gomp_team_barrier_wake (&team->barrier, 1); + } +} + + +// original version of GOMP_task () +/* Called when encountering an explicit task directive. If IF_CLAUSE is + false, then we must not delay in executing the task. If UNTIED is true, + then the task may be executed by any member of the team. + + DEPEND is an array containing: + depend[0]: number of depend elements. + depend[1]: number of depend elements of type "out". + depend[2..N+1]: address of [1..N]th depend element. */ + +/* Commented for test */ +// void +// GOMP_task (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *), +// long arg_size, long arg_align, bool if_clause, unsigned flags, +// void **depend, int priority) +// { +// struct gomp_thread *thr = gomp_thread (); +// struct gomp_team *team = thr->ts.team; +// +// #ifdef HAVE_BROKEN_POSIX_SEMAPHORES +// /* If pthread_mutex_* is used for omp_*lock*, then each task must be +// tied to one thread all the time. This means UNTIED tasks must be +// tied and if CPYFN is non-NULL IF(0) must be forced, as CPYFN +// might be running on different thread than FN. */ +// if (cpyfn) +// if_clause = false; +// flags &= ~GOMP_TASK_FLAG_UNTIED; +// #endif +// +// /* If parallel or taskgroup has been cancelled, don't start new tasks. */ +// if (team +// && (gomp_team_barrier_cancelled (&team->barrier) +// || (thr->task->taskgroup && thr->task->taskgroup->cancelled))) +// return; +// +// if ((flags & GOMP_TASK_FLAG_PRIORITY) == 0) +// priority = 0; +// else if (priority > gomp_max_task_priority_var) +// priority = gomp_max_task_priority_var; +// +// if (!if_clause || team == NULL +// || (thr->task && thr->task->final_task) +// || team->task_count > 64 * team->nthreads) +// { +// struct gomp_task task; +// +// /* If there are depend clauses and earlier deferred sibling tasks +// with depend clauses, check if there isn't a dependency. If there +// is, we need to wait for them. There is no need to handle +// depend clauses for non-deferred tasks other than this, because +// the parent task is suspended until the child task finishes and thus +// it can't start further child tasks. */ +// if ((flags & GOMP_TASK_FLAG_DEPEND) +// && thr->task && thr->task->depend_hash) +// gomp_task_maybe_wait_for_dependencies (depend); +// +// gomp_init_task (&task, thr->task, gomp_icv (false)); +// task.kind = GOMP_TASK_UNDEFERRED; +// task.final_task = (thr->task && thr->task->final_task) +// || (flags & GOMP_TASK_FLAG_FINAL); +// task.priority = priority; +// if (thr->task) +// { +// task.in_tied_task = thr->task->in_tied_task; +// task.taskgroup = thr->task->taskgroup; +// } +// thr->task = &task; +// if (__builtin_expect (cpyfn != NULL, 0)) +// { +// char buf[arg_size + arg_align - 1]; +// char *arg = (char *) (((uintptr_t) buf + arg_align - 1) +// & ~(uintptr_t) (arg_align - 1)); +// cpyfn (arg, data); +// fn (arg); +// } +// else +// fn (data); +// /* Access to "children" is normally done inside a task_lock +// mutex region, but the only way this particular task.children +// can be set is if this thread's task work function (fn) +// creates children. So since the setter is *this* thread, we +// need no barriers here when testing for non-NULL. We can have +// task.children set by the current thread then changed by a +// child thread, but seeing a stale non-NULL value is not a +// problem. Once past the task_lock acquisition, this thread +// will see the real value of task.children. */ +// if (!priority_queue_empty_p (&task.children_queue, MEMMODEL_RELAXED)) +// { +// gomp_mutex_lock (&team->task_lock); +// gomp_clear_parent (&task.children_queue); +// gomp_mutex_unlock (&team->task_lock); +// } +// gomp_end_task (); +// } +// else +// { +// struct gomp_task *task; +// struct gomp_task *parent = thr->task; +// struct gomp_taskgroup *taskgroup = parent->taskgroup; +// char *arg; +// bool do_wake; +// size_t depend_size = 0; +// +// if (flags & GOMP_TASK_FLAG_DEPEND) +// depend_size = ((uintptr_t) depend[0] +// * sizeof (struct gomp_task_depend_entry)); +// task = gomp_malloc (sizeof (*task) + depend_size +// + arg_size + arg_align - 1); +// arg = (char *) (((uintptr_t) (task + 1) + depend_size + arg_align - 1) +// & ~(uintptr_t) (arg_align - 1)); +// gomp_init_task (task, parent, gomp_icv (false)); +// task->priority = priority; +// task->kind = GOMP_TASK_UNDEFERRED; +// task->in_tied_task = parent->in_tied_task; +// task->taskgroup = taskgroup; +// thr->task = task; +// if (cpyfn) +// { +// cpyfn (arg, data); +// task->copy_ctors_done = true; +// } +// else +// memcpy (arg, data, arg_size); +// thr->task = parent; +// task->kind = GOMP_TASK_WAITING; +// task->fn = fn; +// task->fn_data = arg; +// task->final_task = (flags & GOMP_TASK_FLAG_FINAL) >> 1; +// gomp_mutex_lock (&team->task_lock); +// /* If parallel or taskgroup has been cancelled, don't start new +// tasks. */ +// if (__builtin_expect ((gomp_team_barrier_cancelled (&team->barrier) +// || (taskgroup && taskgroup->cancelled)) +// && !task->copy_ctors_done, 0)) +// { + // gomp_mutex_unlock (&team->task_lock); + // gomp_finish_task (task); + // free (task); + // return; + // } + // if (taskgroup) + // taskgroup->num_children++; + // if (depend_size) + // { + // gomp_task_handle_depend (task, parent, depend); + // if (task->num_dependees) + // { + // /* Tasks that depend on other tasks are not put into the + // various waiting queues, so we are done for now. Said + // tasks are instead put into the queues via + // gomp_task_run_post_handle_dependers() after their + // dependencies have been satisfied. After which, they + // can be picked up by the various scheduling + // points. */ + // gomp_mutex_unlock (&team->task_lock); + // return; + // } + // } + // + // priority_queue_insert (PQ_CHILDREN, &parent->children_queue, + // task, priority, + // PRIORITY_INSERT_BEGIN, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + // if (taskgroup) + // priority_queue_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + // task, priority, + // PRIORITY_INSERT_BEGIN, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + // + // priority_queue_insert (PQ_TEAM, &team->task_queue, + // task, priority, + // PRIORITY_INSERT_END, + // /*adjust_parent_depends_on=*/false, + // task->parent_depends_on); + // + // ++team->task_count; + // ++team->task_queued_count; + // gomp_team_barrier_set_task_pending (&team->barrier); + // do_wake = team->task_running_count + !parent->in_tied_task + // < team->nthreads; + // gomp_mutex_unlock (&team->task_lock); + // if (do_wake) + // gomp_team_barrier_wake (&team->barrier, 1); + // } + // } + + ialias (GOMP_taskgroup_start) + ialias (GOMP_taskgroup_end) + + #define TYPE long + #define UTYPE unsigned long + #define TYPE_is_long 1 + #include "taskloop.c" + #undef TYPE + #undef UTYPE + #undef TYPE_is_long + + #define TYPE unsigned long long + #define UTYPE TYPE + #define GOMP_taskloop GOMP_taskloop_ull + #include "taskloop.c" + #undef TYPE + #undef UTYPE + #undef GOMP_taskloop + + static void inline + priority_queue_move_task_first (enum priority_queue_type type, + struct priority_queue *head, + struct gomp_task *task) + { + #if _LIBGOMP_CHECKING_ + if (!priority_queue_task_in_queue_p (type, head, task)) + gomp_fatal ("Attempt to move first missing task %p", task); + #endif + struct priority_list *list; + if (priority_queue_multi_p (head)) + { + list = priority_queue_lookup_priority (head, task->priority); + #if _LIBGOMP_CHECKING_ + if (!list) + gomp_fatal ("Unable to find priority %d", task->priority); + #endif + } + else + list = &head->l; + priority_list_remove (list, task_to_priority_node (type, task), 0); + priority_list_insert (type, list, task, task->priority, + PRIORITY_INSERT_BEGIN, type == PQ_CHILDREN, + task->parent_depends_on); + } + + /* Actual body of GOMP_PLUGIN_target_task_completion that is executed + with team->task_lock held, or is executed in the thread that called + gomp_target_task_fn if GOMP_PLUGIN_target_task_completion has been + run before it acquires team->task_lock. */ + + static void + gomp_target_task_completion (struct gomp_team *team, struct gomp_task *task) + { + struct gomp_task *parent = task->parent; + if (parent) + priority_queue_move_task_first (PQ_CHILDREN, &parent->children_queue, + task); + + struct gomp_taskgroup *taskgroup = task->taskgroup; + if (taskgroup) + priority_queue_move_task_first (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + task); + + priority_queue_insert (PQ_TEAM, &team->task_queue, task, task->priority, + PRIORITY_INSERT_BEGIN, false, + task->parent_depends_on); + task->kind = GOMP_TASK_WAITING; + if (parent && parent->taskwait) + { + if (parent->taskwait->in_taskwait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + parent->taskwait->in_taskwait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + else if (parent->taskwait->in_depend_wait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + parent->taskwait->in_depend_wait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + } + if (taskgroup && taskgroup->in_taskgroup_wait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + taskgroup->in_taskgroup_wait = false; + gomp_sem_post (&taskgroup->taskgroup_sem); + } + + ++team->task_queued_count; + gomp_team_barrier_set_task_pending (&team->barrier); + /* I'm afraid this can't be done after releasing team->task_lock, + as gomp_target_task_completion is run from unrelated thread and + therefore in between gomp_mutex_unlock and gomp_team_barrier_wake + the team could be gone already. */ + if (team->nthreads > team->task_running_count) + gomp_team_barrier_wake (&team->barrier, 1); + } + + /* Signal that a target task TTASK has completed the asynchronously + running phase and should be requeued as a task to handle the + variable unmapping. */ + + void + GOMP_PLUGIN_target_task_completion (void *data) + { + struct gomp_target_task *ttask = (struct gomp_target_task *) data; + struct gomp_task *task = ttask->task; + struct gomp_team *team = ttask->team; + + gomp_mutex_lock (&team->task_lock); + if (ttask->state == GOMP_TARGET_TASK_READY_TO_RUN) + { + ttask->state = GOMP_TARGET_TASK_FINISHED; + gomp_mutex_unlock (&team->task_lock); + return; + } + ttask->state = GOMP_TARGET_TASK_FINISHED; + gomp_target_task_completion (team, task); + gomp_mutex_unlock (&team->task_lock); + } + + static void gomp_task_run_post_handle_depend_hash (struct gomp_task *); + + /* Called for nowait target tasks. */ + + bool + gomp_create_target_task (struct gomp_device_descr *devicep, + void (*fn) (void *), size_t mapnum, void **hostaddrs, + size_t *sizes, unsigned short *kinds, + unsigned int flags, void **depend, void **args, + enum gomp_target_task_state state) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + + /* If parallel or taskgroup has been cancelled, don't start new tasks. */ + if (team + && (gomp_team_barrier_cancelled (&team->barrier) + || (thr->task->taskgroup && thr->task->taskgroup->cancelled))) + return true; + + struct gomp_target_task *ttask; + struct gomp_task *task; + struct gomp_task *parent = thr->task; + struct gomp_taskgroup *taskgroup = parent->taskgroup; + bool do_wake; + size_t depend_size = 0; + uintptr_t depend_cnt = 0; + size_t tgt_align = 0, tgt_size = 0; + + if (depend != NULL) + { + depend_cnt = (uintptr_t) depend[0]; + depend_size = depend_cnt * sizeof (struct gomp_task_depend_entry); + } + if (fn) + { + /* GOMP_MAP_FIRSTPRIVATE need to be copied first, as they are + firstprivate on the target task. */ + size_t i; + for (i = 0; i < mapnum; i++) + if ((kinds[i] & 0xff) == GOMP_MAP_FIRSTPRIVATE) + { + size_t align = (size_t) 1 << (kinds[i] >> 8); + if (tgt_align < align) + tgt_align = align; + tgt_size = (tgt_size + align - 1) & ~(align - 1); + tgt_size += sizes[i]; + } + if (tgt_align) + tgt_size += tgt_align - 1; + else + tgt_size = 0; + } + + task = gomp_malloc (sizeof (*task) + depend_size + + sizeof (*ttask) + + mapnum * (sizeof (void *) + sizeof (size_t) + + sizeof (unsigned short)) + + tgt_size); + gomp_init_task (task, parent, gomp_icv (false)); + task->priority = 0; + task->kind = GOMP_TASK_WAITING; + task->in_tied_task = parent->in_tied_task; + task->taskgroup = taskgroup; + ttask = (struct gomp_target_task *) &task->depend[depend_cnt]; + ttask->devicep = devicep; + ttask->fn = fn; + ttask->mapnum = mapnum; + ttask->args = args; + memcpy (ttask->hostaddrs, hostaddrs, mapnum * sizeof (void *)); + ttask->sizes = (size_t *) &ttask->hostaddrs[mapnum]; + memcpy (ttask->sizes, sizes, mapnum * sizeof (size_t)); + ttask->kinds = (unsigned short *) &ttask->sizes[mapnum]; + memcpy (ttask->kinds, kinds, mapnum * sizeof (unsigned short)); + if (tgt_align) + { + char *tgt = (char *) &ttask->kinds[mapnum]; + size_t i; + uintptr_t al = (uintptr_t) tgt & (tgt_align - 1); + if (al) + tgt += tgt_align - al; + tgt_size = 0; + for (i = 0; i < mapnum; i++) + if ((kinds[i] & 0xff) == GOMP_MAP_FIRSTPRIVATE) + { + size_t align = (size_t) 1 << (kinds[i] >> 8); + tgt_size = (tgt_size + align - 1) & ~(align - 1); + memcpy (tgt + tgt_size, hostaddrs[i], sizes[i]); + ttask->hostaddrs[i] = tgt + tgt_size; + tgt_size = tgt_size + sizes[i]; + } + } + ttask->flags = flags; + ttask->state = state; + ttask->task = task; + ttask->team = team; + task->fn = NULL; + task->fn_data = ttask; + task->final_task = 0; + gomp_mutex_lock (&team->task_lock); + /* If parallel or taskgroup has been cancelled, don't start new tasks. */ + if (__builtin_expect (gomp_team_barrier_cancelled (&team->barrier) + || (taskgroup && taskgroup->cancelled), 0)) + { + gomp_mutex_unlock (&team->task_lock); + gomp_finish_task (task); + free (task); + return true; + } + if (depend_size) + { + gomp_task_handle_depend (task, parent, depend); + if (task->num_dependees) + { + if (taskgroup) + taskgroup->num_children++; + gomp_mutex_unlock (&team->task_lock); + return true; + } + } + if (state == GOMP_TARGET_TASK_DATA) + { + gomp_task_run_post_handle_depend_hash (task); + gomp_mutex_unlock (&team->task_lock); + gomp_finish_task (task); + free (task); + return false; + } + if (taskgroup) + taskgroup->num_children++; + /* For async offloading, if we don't need to wait for dependencies, + run the gomp_target_task_fn right away, essentially schedule the + mapping part of the task in the current thread. */ + if (devicep != NULL + && (devicep->capabilities & GOMP_OFFLOAD_CAP_OPENMP_400)) + { + priority_queue_insert (PQ_CHILDREN, &parent->children_queue, task, 0, + PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + if (taskgroup) + priority_queue_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + task, 0, PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + task->pnode[PQ_TEAM].next = NULL; + task->pnode[PQ_TEAM].prev = NULL; + task->kind = GOMP_TASK_TIED; + ++team->task_count; + gomp_mutex_unlock (&team->task_lock); + + thr->task = task; + gomp_target_task_fn (task->fn_data); + thr->task = parent; + + gomp_mutex_lock (&team->task_lock); + task->kind = GOMP_TASK_ASYNC_RUNNING; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + gomp_mutex_unlock (&team->task_lock); + return true; + } + priority_queue_insert (PQ_CHILDREN, &parent->children_queue, task, 0, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + if (taskgroup) + priority_queue_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, task, 0, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + priority_queue_insert (PQ_TEAM, &team->task_queue, task, 0, + PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + ++team->task_count; + ++team->task_queued_count; + gomp_team_barrier_set_task_pending (&team->barrier); + do_wake = team->task_running_count + !parent->in_tied_task + < team->nthreads; + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + gomp_team_barrier_wake (&team->barrier, 1); + return true; + } + + /* Given a parent_depends_on task in LIST, move it to the front of its + priority so it is run as soon as possible. + + Care is taken to update the list's LAST_PARENT_DEPENDS_ON field. + + We rearrange the queue such that all parent_depends_on tasks are + first, and last_parent_depends_on points to the last such task we + rearranged. For example, given the following tasks in a queue + where PD[123] are the parent_depends_on tasks: + + task->children + | + V + C1 -> C2 -> C3 -> PD1 -> PD2 -> PD3 -> C4 + + We rearrange such that: + + task->children + | +--- last_parent_depends_on + | | + V V + PD1 -> PD2 -> PD3 -> C1 -> C2 -> C3 -> C4. */ + + static void inline + priority_list_upgrade_task (struct priority_list *list, + struct priority_node *node) + { + struct priority_node *last_parent_depends_on + = list->last_parent_depends_on; + if (last_parent_depends_on) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->prev = last_parent_depends_on; + node->next = last_parent_depends_on->next; + node->prev->next = node; + node->next->prev = node; + } + else if (node != list->tasks) + { + node->prev->next = node->next; + node->next->prev = node->prev; + node->prev = list->tasks->prev; + node->next = list->tasks; + list->tasks = node; + node->prev->next = node; + node->next->prev = node; + } + list->last_parent_depends_on = node; + } + + /* Given a parent_depends_on TASK in its parent's children_queue, move + it to the front of its priority so it is run as soon as possible. + + PARENT is passed as an optimization. + + (This function could be defined in priority_queue.c, but we want it + inlined, and putting it in priority_queue.h is not an option, given + that gomp_task has not been properly defined at that point). */ + + static void inline + priority_queue_upgrade_task (struct gomp_task *task, + struct gomp_task *parent) + { + struct priority_queue *head = &parent->children_queue; + struct priority_node *node = &task->pnode[PQ_CHILDREN]; + #if _LIBGOMP_CHECKING_ + if (!task->parent_depends_on) + gomp_fatal ("priority_queue_upgrade_task: task must be a " + "parent_depends_on task"); + if (!priority_queue_task_in_queue_p (PQ_CHILDREN, head, task)) // Function not yet implemented + gomp_fatal ("priority_queue_upgrade_task: cannot find task=%p", task); + #endif + if (priority_queue_multi_p (head)) + { + struct priority_list *list + = priority_queue_lookup_priority (head, task->priority); + priority_list_upgrade_task (list, node); + } + else + priority_list_upgrade_task (&head->l, node); + } + + /* Given a CHILD_TASK in LIST that is about to be executed, move it out of + the way in LIST so that other tasks can be considered for + execution. LIST contains tasks of type TYPE. + + Care is taken to update the queue's LAST_PARENT_DEPENDS_ON field + if applicable. */ + + static void inline + priority_list_downgrade_task (enum priority_queue_type type, + struct priority_list *list, + struct gomp_task *child_task) + { + struct priority_node *node = task_to_priority_node (type, child_task); + if (list->tasks == node) + list->tasks = node->next; + else if (node->next != list->tasks) + { + /* The task in NODE is about to become TIED and TIED tasks + cannot come before WAITING tasks. If we're about to + leave the queue in such an indeterminate state, rewire + things appropriately. However, a TIED task at the end is + perfectly fine. */ + struct gomp_task *next_task = priority_node_to_task (type, node->next); + if (next_task->kind == GOMP_TASK_WAITING) + { + /* Remove from list. */ + node->prev->next = node->next; + node->next->prev = node->prev; + /* Rewire at the end. */ + node->next = list->tasks; + node->prev = list->tasks->prev; + list->tasks->prev->next = node; + list->tasks->prev = node; + } + } + + /* If the current task is the last_parent_depends_on for its + priority, adjust last_parent_depends_on appropriately. */ + if (__builtin_expect (child_task->parent_depends_on, 0) + && list->last_parent_depends_on == node) + { + struct gomp_task *prev_child = priority_node_to_task (type, node->prev); + if (node->prev != node + && prev_child->kind == GOMP_TASK_WAITING + && prev_child->parent_depends_on) + list->last_parent_depends_on = node->prev; + else + { + /* There are no more parent_depends_on entries waiting + to run, clear the list. */ + list->last_parent_depends_on = NULL; + } + } + } + + /* Given a TASK in HEAD that is about to be executed, move it out of + the way so that other tasks can be considered for execution. HEAD + contains tasks of type TYPE. + + Care is taken to update the queue's LAST_PARENT_DEPENDS_ON field + if applicable. + + (This function could be defined in priority_queue.c, but we want it + inlined, and putting it in priority_queue.h is not an option, given + that gomp_task has not been properly defined at that point). */ + + static void inline + priority_queue_downgrade_task (enum priority_queue_type type, + struct priority_queue *head, + struct gomp_task *task) + { + #if _LIBGOMP_CHECKING_ + if (!priority_queue_task_in_queue_p (type, head, task)) + gomp_fatal ("Attempt to downgrade missing task %p", task); + #endif + if (priority_queue_multi_p (head)) + { + struct priority_list *list + = priority_queue_lookup_priority (head, task->priority); + priority_list_downgrade_task (type, list, task); + } + else + priority_list_downgrade_task (type, &head->l, task); + } + + /* Setup CHILD_TASK to execute. This is done by setting the task to + TIED, and updating all relevant queues so that CHILD_TASK is no + longer chosen for scheduling. Also, remove CHILD_TASK from the + overall team task queue entirely. + + Return TRUE if task or its containing taskgroup has been + cancelled. */ + + static inline bool + gomp_task_run_pre (struct gomp_task *child_task, struct gomp_task *parent, + struct gomp_team *team) + { + #if _LIBGOMP_CHECKING_ + if (child_task->parent) + priority_queue_verify (PQ_CHILDREN, + &child_task->parent->children_queue, true); + if (child_task->taskgroup) + priority_queue_verify (PQ_TASKGROUP, + &child_task->taskgroup->taskgroup_queue, false); + priority_queue_verify (PQ_TEAM, &team->task_queue, false); + #endif + + /* Task is about to go tied, move it out of the way. */ + if (parent) + priority_queue_downgrade_task (PQ_CHILDREN, &parent->children_queue, + child_task); + + /* Task is about to go tied, move it out of the way. */ + struct gomp_taskgroup *taskgroup = child_task->taskgroup; + if (taskgroup) + priority_queue_downgrade_task (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + child_task); + + priority_queue_remove (PQ_TEAM, &team->task_queue, child_task, + MEMMODEL_RELAXED); + child_task->pnode[PQ_TEAM].next = NULL; + child_task->pnode[PQ_TEAM].prev = NULL; + child_task->kind = GOMP_TASK_TIED; + + if (--team->task_queued_count == 0) + gomp_team_barrier_clear_task_pending (&team->barrier); + if ((gomp_team_barrier_cancelled (&team->barrier) + || (taskgroup && taskgroup->cancelled)) + && !child_task->copy_ctors_done) + return true; + return false; + } + + + /* same function for static tdg task */ + + static inline bool + gomp_tdg_task_run_pre (struct gomp_tdg_task *child_task, struct gomp_team *team) + { + priority_queue_tdg_remove (PQ_TEAM, &team->task_queue, child_task, + MEMMODEL_RELAXED); + child_task->pnode[PQ_TEAM].next = NULL; + child_task->pnode[PQ_TEAM].prev = NULL; + child_task->kind = GOMP_TASK_TIED; + + if (--team->task_queued_count == 0) + gomp_team_barrier_clear_task_pending (&team->barrier); + if ((gomp_team_barrier_cancelled (&team->barrier) + /* || (taskgroup && taskgroup->cancelled)) + && !child_task->copy_ctors_done)*/)) + return true; + return false; + } + + + static void + gomp_task_run_post_handle_depend_hash (struct gomp_task *child_task) + { + struct gomp_task *parent = child_task->parent; + size_t i; + + for (i = 0; i < child_task->depend_count; i++) + if (!child_task->depend[i].redundant) + { + if (child_task->depend[i].next) + child_task->depend[i].next->prev = child_task->depend[i].prev; + if (child_task->depend[i].prev) + child_task->depend[i].prev->next = child_task->depend[i].next; + else + { + hash_entry_type *slot + = htab_find_slot (&parent->depend_hash, &child_task->depend[i], + NO_INSERT); + if (*slot != &child_task->depend[i]) + abort (); + if (child_task->depend[i].next) + *slot = child_task->depend[i].next; + else + htab_clear_slot (parent->depend_hash, slot); + } + } + } + + /* After a CHILD_TASK has been run, adjust the dependency queue for + each task that depends on CHILD_TASK, to record the fact that there + is one less dependency to worry about. If a task that depended on + CHILD_TASK now has no dependencies, place it in the various queues + so it gets scheduled to run. + + TEAM is the team to which CHILD_TASK belongs to. */ + + static size_t + gomp_task_run_post_handle_dependers (struct gomp_task *child_task, + struct gomp_team *team) + { + struct gomp_task *parent = child_task->parent; + size_t i, count = child_task->dependers->n_elem, ret = 0; + for (i = 0; i < count; i++) + { + struct gomp_task *task = child_task->dependers->elem[i]; + + /* CHILD_TASK satisfies a dependency for TASK. Keep track of + TASK's remaining dependencies. Once TASK has no other + depenencies, put it into the various queues so it will get + scheduled for execution. */ + if (--task->num_dependees != 0) + continue; + + struct gomp_taskgroup *taskgroup = task->taskgroup; + if (parent) + { + priority_queue_insert (PQ_CHILDREN, &parent->children_queue, + task, task->priority, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/true, + task->parent_depends_on); + if (parent->taskwait) + { + if (parent->taskwait->in_taskwait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + parent->taskwait->in_taskwait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + else if (parent->taskwait->in_depend_wait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + parent->taskwait->in_depend_wait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + } + } + if (taskgroup) + { + priority_queue_insert (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + task, task->priority, + PRIORITY_INSERT_BEGIN, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + if (taskgroup->in_taskgroup_wait) + { + /* One more task has had its dependencies met. + Inform any waiters. */ + taskgroup->in_taskgroup_wait = false; + gomp_sem_post (&taskgroup->taskgroup_sem); + } + } + priority_queue_insert (PQ_TEAM, &team->task_queue, + task, task->priority, + PRIORITY_INSERT_END, + /*adjust_parent_depends_on=*/false, + task->parent_depends_on); + ++team->task_count; + ++team->task_queued_count; + ++ret; + } + free (child_task->dependers); + child_task->dependers = NULL; + if (ret > 1) + gomp_team_barrier_set_task_pending (&team->barrier); + return ret; + } + + static inline size_t + gomp_task_run_post_handle_depend (struct gomp_task *child_task, + struct gomp_team *team) + { + if (child_task->depend_count == 0) + return 0; + + /* If parent is gone already, the hash table is freed and nothing + will use the hash table anymore, no need to remove anything from it. */ + if (child_task->parent != NULL) + gomp_task_run_post_handle_depend_hash (child_task); + + if (child_task->dependers == NULL) + return 0; + + return gomp_task_run_post_handle_dependers (child_task, team); + } + + /* Remove CHILD_TASK from its parent. */ + + static inline void + gomp_task_run_post_remove_parent (struct gomp_task *child_task) + { + struct gomp_task *parent = child_task->parent; + if (parent == NULL) + return; + + /* If this was the last task the parent was depending on, + synchronize with gomp_task_maybe_wait_for_dependencies so it can + clean up and return. */ + if (__builtin_expect (child_task->parent_depends_on, 0) + && --parent->taskwait->n_depend == 0 + && parent->taskwait->in_depend_wait) + { + parent->taskwait->in_depend_wait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + + if (priority_queue_remove (PQ_CHILDREN, &parent->children_queue, + child_task, MEMMODEL_RELEASE) + && parent->taskwait && parent->taskwait->in_taskwait) + { + parent->taskwait->in_taskwait = false; + gomp_sem_post (&parent->taskwait->taskwait_sem); + } + child_task->pnode[PQ_CHILDREN].next = NULL; + child_task->pnode[PQ_CHILDREN].prev = NULL; + } + + /* Remove CHILD_TASK from its taskgroup. */ + + static inline void + gomp_task_run_post_remove_taskgroup (struct gomp_task *child_task) + { + struct gomp_taskgroup *taskgroup = child_task->taskgroup; + if (taskgroup == NULL) + return; + bool empty = priority_queue_remove (PQ_TASKGROUP, + &taskgroup->taskgroup_queue, + child_task, MEMMODEL_RELAXED); + child_task->pnode[PQ_TASKGROUP].next = NULL; + child_task->pnode[PQ_TASKGROUP].prev = NULL; + if (taskgroup->num_children > 1) + --taskgroup->num_children; + else + { + /* We access taskgroup->num_children in GOMP_taskgroup_end + outside of the task lock mutex region, so + need a release barrier here to ensure memory + written by child_task->fn above is flushed + before the NULL is written. */ + __atomic_store_n (&taskgroup->num_children, 0, MEMMODEL_RELEASE); + } + if (empty && taskgroup->in_taskgroup_wait) + { + taskgroup->in_taskgroup_wait = false; + gomp_sem_post (&taskgroup->taskgroup_sem); + } + } + + // + // /* function implmenting two different behaviours, static or dynamic tdg */ + // void + // gomp_barrier_handle_tasks (gomp_barrier_state_t state) + // { + // struct gomp_thread *thr = gomp_thread (); + // struct gomp_team *team = thr->ts.team; + // struct gomp_task *task = thr->task; + // + // /* for dynamic tdg tasks */ + // struct gomp_task *child_task = NULL; + // struct gomp_task *to_free = NULL; + // + // /* for static tdg tasks */ + // struct gomp_tdg_task *child_tdg_task = NULL; + // struct gomp_tdg_task *tdg_to_free = NULL; + // + // int do_wake = 0; + // + // // new_tasks moved to here so that gomp_update_tdg_dependency can access to it + // size_t new_tasks = 0; + // + // + // gomp_mutex_lock (&team->task_lock); + // if (gomp_barrier_last_thread (state)) + // { + // if (team->task_count == 0) + // { + // gomp_team_barrier_done (&team->barrier, state); + // gomp_mutex_unlock (&team->task_lock); + // gomp_team_barrier_wake (&team->barrier, 0); + // return; + // } + // gomp_team_barrier_set_waiting_for_tasks (&team->barrier); + // } + // + // /* + // while (1) + // { + // */ + // bool cancelled; + // + // if(!STATIC_TDG) + // goto loop_dynamic_TDG; + // + // loop_static_TDG:; + // cancelled = false; + // // priority_queue_empty_p returns true if queue is empty + // if (!priority_queue_empty_p (&team->task_queue, MEMMODEL_RELAXED)) + // { + // child_tdg_task + // = priority_queue_next_tdg_task (PQ_TEAM, &team->task_queue); + // cancelled = gomp_tdg_task_run_pre (child_tdg_task, team); + // + // if (__builtin_expect (cancelled, 0)) + // { + // if (tdg_to_free) + // { + // free (tdg_to_free); + // tdg_to_free = NULL; + // } + // goto finish_tdg_cancelled; + // } + // team->task_running_count++; + // + // child_tdg_task->in_tied_task = true; + // } + // gomp_mutex_unlock (&team->task_lock); + // if (do_wake) + // { + // gomp_team_barrier_wake (&team->barrier, do_wake); + // do_wake = 0; + // } + // if (tdg_to_free) + // { + // free (tdg_to_free); + // tdg_to_free = NULL; + // } + // if (child_tdg_task) + // { + // thr->task = child_task; // thr->task = NULL; + // + // /* target task, not implemented with static task yet + // just changed child_task to child_tdg_task, those + // as function parameters are not changed */ + // if (__builtin_expect (child_tdg_task->fn == NULL, 0)) + // { + // if (gomp_target_task_fn (child_tdg_task->fn_data)) + // { + // thr->task = task; + // gomp_mutex_lock (&team->task_lock); + // child_tdg_task->kind = GOMP_TASK_ASYNC_RUNNING; + // team->task_running_count--; + // struct gomp_target_task *ttask + // = (struct gomp_target_task *) child_task->fn_data; + // /* If GOMP_PLUGIN_target_task_completion has run already + // in between gomp_target_task_fn and the mutex lock, + // perform the requeuing here. */ + // if (ttask->state == GOMP_TARGET_TASK_FINISHED) + // gomp_target_task_completion (team, child_task); + // else + // ttask->state = GOMP_TARGET_TASK_RUNNING; + // child_tdg_task = NULL; + // // continue; because while is commented + // goto loop_static_TDG; + // + // } + // } + // else + // { + // child_tdg_task->fn(child_tdg_task->fn_data); + // new_tasks = (size_t)gomp_update_tdg_dependency(child_tdg_task); //update cnt of tdg node depend on child_task + // } + // thr->task = task; + // }else + // return; + // + // gomp_mutex_lock (&team->task_lock); + // if (child_tdg_task) + // { + // finish_tdg_cancelled:; + // + // tdg_to_free = child_tdg_task; + // child_tdg_task = NULL; + // + // if (!cancelled) + // team->task_running_count--; + // if (new_tasks > 1) + // { + // do_wake = team->nthreads - team->task_running_count; + // if (do_wake > new_tasks) + // do_wake = new_tasks; + // } + // if (--team->task_count == 0 + // && gomp_team_barrier_waiting_for_tasks (&team->barrier)) + // { + // gomp_team_barrier_done (&team->barrier, state); + // gomp_mutex_unlock (&team->task_lock); + // gomp_team_barrier_wake (&team->barrier, 0); + // gomp_mutex_lock (&team->task_lock); + // } + // } + // goto loop_static_TDG; + // + // loop_dynamic_TDG:; + // cancelled = false; + // if (!priority_queue_empty_p (&team->task_queue, MEMMODEL_RELAXED)) + // { + // bool ignored; + // child_task + // = priority_queue_next_task (PQ_TEAM, &team->task_queue, + // PQ_IGNORED, NULL, + // &ignored); + // cancelled = gomp_task_run_pre (child_task, child_task->parent, + // team); + // + // if (__builtin_expect (cancelled, 0)) + // { + // if (to_free) + // { + // free (to_free); + // to_free = NULL; + // } + // goto finish_cancelled; + // } + // team->task_running_count++; + // + // child_task->in_tied_task = true; + // } + // gomp_mutex_unlock (&team->task_lock); + // if (do_wake) + // { + // gomp_team_barrier_wake (&team->barrier, do_wake); + // do_wake = 0; + // } + // if (to_free) + // { + // free (to_free); + // to_free = NULL; + // } + // if (child_task) + // { + // thr->task = child_task; + // + // if (__builtin_expect (child_task->fn == NULL, 0)) + // { + // if (gomp_target_task_fn (child_task->fn_data)) + // { + // thr->task = task; + // gomp_mutex_lock (&team->task_lock); + // child_task->kind = GOMP_TASK_ASYNC_RUNNING; + // team->task_running_count--; + // struct gomp_target_task *ttask + // = (struct gomp_target_task *) child_task->fn_data; + // /* If GOMP_PLUGIN_target_task_completion has run already + // in between gomp_target_task_fn and the mutex lock, + // perform the requeuing here. */ + // if (ttask->state == GOMP_TARGET_TASK_FINISHED) + // gomp_target_task_completion (team, child_task); + // else + // ttask->state = GOMP_TARGET_TASK_RUNNING; + // child_task = NULL; + // // continue; because while is commented + // goto loop_dynamic_TDG; + // } + // } + // else + // child_task->fn(child_task->fn_data); + // thr->task = task; + // }else + // return; + // + // gomp_mutex_lock (&team->task_lock); + // if (child_task) + // { + // finish_cancelled:; + // size_t new_tasks + // = gomp_task_run_post_handle_depend (child_task, team); + // gomp_task_run_post_remove_parent (child_task); + // gomp_clear_parent (&child_task->children_queue); + // gomp_task_run_post_remove_taskgroup (child_task); + // to_free = child_task; + // child_task = NULL; + // + // if (!cancelled) + // team->task_running_count--; + // if (new_tasks > 1) + // { + // do_wake = team->nthreads - team->task_running_count; + // if (do_wake > new_tasks) + // do_wake = new_tasks; + // } + // if (--team->task_count == 0 + // && gomp_team_barrier_waiting_for_tasks (&team->barrier)) + // { + // gomp_team_barrier_done (&team->barrier, state); + // gomp_mutex_unlock (&team->task_lock); + // gomp_team_barrier_wake (&team->barrier, 0); + // gomp_mutex_lock (&team->task_lock); + // } + // } + // goto loop_dynamic_TDG; + // // } while + // } + + void + gomp_barrier_handle_tasks (gomp_barrier_state_t state) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + struct gomp_task *task = thr->task; + struct gomp_task *child_task = NULL; + struct gomp_task *to_free = NULL; + int do_wake = 0; + + /* for static tdg tasks adaptation */ + union task_union_t *task_u = NULL; + struct gomp_tdg_task *tdg_task = NULL; + strict gomp_tdg_task *tdg_to_free = NULL; + int is_static; + + + gomp_mutex_lock (&team->task_lock); + if (gomp_barrier_last_thread (state)) + { + if (team->task_count == 0) + { + gomp_team_barrier_done (&team->barrier, state); + gomp_mutex_unlock (&team->task_lock); + gomp_team_barrier_wake (&team->barrier, 0); + return; + } + gomp_team_barrier_set_waiting_for_tasks (&team->barrier); + } + + while (1) + { + bool cancelled = false; + if (!priority_queue_empty_p (&team->task_queue, MEMMODEL_RELAXED)) + { + bool ignored; + task_u + = priority_queue_next_gen_task (PQ_TEAM, &team->task_queue, + PQ_IGNORED, NULL, + &ignored, &is_static); + if (is_static != GOMP_STATIC_TDG) + { + child_task = &task_u->task; + cancelled = gomp_task_run_pre (child_task, child_task->parent, team); + }else{ + child_tdg_task = &task_u->tdg_task; + cancelled = gomp_tdg_task_run_pre (child_tdg_task, team); + } + + if (__builtin_expect (cancelled, 0)) + { + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + if (tdg_to_free) + { + free (tdg_to_free); + tdg_to_free = NULL; + } + goto finish_cancelled; + } + team->task_running_count++; + child_task->in_tied_task = true; + } + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + { + gomp_team_barrier_wake (&team->barrier, do_wake); + do_wake = 0; + } + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + if (tdg_to_free) + { + free (tdg_to_free); + tdg_to_free = NULL; + } + + if (is_static != GOMP_STATIC_TDG) + { + if (child_task) + { + thr->task = child_task; + if (__builtin_expect (child_task->fn == NULL, 0)) + { + if (gomp_target_task_fn (child_task->fn_data)) + { + thr->task = task; + gomp_mutex_lock (&team->task_lock); + child_task->kind = GOMP_TASK_ASYNC_RUNNING; + team->task_running_count--; + struct gomp_target_task *ttask + = (struct gomp_target_task *) child_task->fn_data; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, child_task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + child_task = NULL; + continue; + } + } + else + child_task->fn (child_task->fn_data); + thr->task = task; + }else + return; + }else{ + if (tdg_child_task) + { + if (__builtin_expect (child_tdg_task->fn == NULL, 0)) + { + if (gomp_target_task_fn (child_tdg_task->fn_data)) + { + thr->task = task; + gomp_mutex_lock (&team->task_lock); + child_task->kind = GOMP_TASK_ASYNC_RUNNING; + team->task_running_count--; + struct gomp_target_task *ttask + = (struct gomp_target_task *) child_task->fn_data; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, child_task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + child_task = NULL; + continue; + } + } + else + child_task->fn (child_task->fn_data); + thr->task = task; + } + else + return; + } + } + gomp_mutex_lock (&team->task_lock); + if (child_task) + { + finish_cancelled:; + size_t new_tasks + = gomp_task_run_post_handle_depend (child_task, team); + gomp_task_run_post_remove_parent (child_task); + gomp_clear_parent (&child_task->children_queue); + gomp_task_run_post_remove_taskgroup (child_task); + to_free = child_task; + child_task = NULL; + if (!cancelled) + team->task_running_count--; + if (new_tasks > 1) + { + do_wake = team->nthreads - team->task_running_count; + if (do_wake > new_tasks) + do_wake = new_tasks; + } + if (--team->task_count == 0 + && gomp_team_barrier_waiting_for_tasks (&team->barrier)) + { + gomp_team_barrier_done (&team->barrier, state); + gomp_mutex_unlock (&team->task_lock); + gomp_team_barrier_wake (&team->barrier, 0); + gomp_mutex_lock (&team->task_lock); + } + } + } + } + + + + + /* Called when encountering a taskwait directive. + + Wait for all children of the current task. */ + + void + GOMP_taskwait (void) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + struct gomp_task *task = thr->task; + struct gomp_task *child_task = NULL; + struct gomp_task *to_free = NULL; + struct gomp_taskwait taskwait; + int do_wake = 0; + + /* The acquire barrier on load of task->children here synchronizes + with the write of a NULL in gomp_task_run_post_remove_parent. It is + not necessary that we synchronize with other non-NULL writes at + this point, but we must ensure that all writes to memory by a + child thread task work function are seen before we exit from + GOMP_taskwait. */ + if (task == NULL + || priority_queue_empty_p (&task->children_queue, MEMMODEL_ACQUIRE)) + return; + + memset (&taskwait, 0, sizeof (taskwait)); + bool child_q = false; + gomp_mutex_lock (&team->task_lock); + while (1) + { + bool cancelled = false; + if (priority_queue_empty_p (&task->children_queue, MEMMODEL_RELAXED)) + { + bool destroy_taskwait = task->taskwait != NULL; + task->taskwait = NULL; + gomp_mutex_unlock (&team->task_lock); + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + } + if (destroy_taskwait) + gomp_sem_destroy (&taskwait.taskwait_sem); + return; + } + struct gomp_task *next_task + = priority_queue_next_task (PQ_CHILDREN, &task->children_queue, + PQ_TEAM, &team->task_queue, &child_q); + if (next_task->kind == GOMP_TASK_WAITING) + { + child_task = next_task; + cancelled + = gomp_task_run_pre (child_task, task, team); + if (__builtin_expect (cancelled, 0)) + { + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + goto finish_cancelled; + } + } + else + { + /* All tasks we are waiting for are either running in other + threads, or they are tasks that have not had their + dependencies met (so they're not even in the queue). Wait + for them. */ + if (task->taskwait == NULL) + { + taskwait.in_depend_wait = false; + gomp_sem_init (&taskwait.taskwait_sem, 0); + task->taskwait = &taskwait; + } + taskwait.in_taskwait = true; + } + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + { + gomp_team_barrier_wake (&team->barrier, do_wake); + do_wake = 0; + } + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + if (child_task) + { + thr->task = child_task; + if (__builtin_expect (child_task->fn == NULL, 0)) + { + if (gomp_target_task_fn (child_task->fn_data)) + { + thr->task = task; + gomp_mutex_lock (&team->task_lock); + child_task->kind = GOMP_TASK_ASYNC_RUNNING; + struct gomp_target_task *ttask + = (struct gomp_target_task *) child_task->fn_data; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, child_task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + child_task = NULL; + continue; + } + } + else + child_task->fn (child_task->fn_data); + thr->task = task; + } + else + gomp_sem_wait (&taskwait.taskwait_sem); + gomp_mutex_lock (&team->task_lock); + if (child_task) + { + finish_cancelled:; + size_t new_tasks + = gomp_task_run_post_handle_depend (child_task, team); + + if (child_q) + { + priority_queue_remove (PQ_CHILDREN, &task->children_queue, + child_task, MEMMODEL_RELAXED); + child_task->pnode[PQ_CHILDREN].next = NULL; + child_task->pnode[PQ_CHILDREN].prev = NULL; + } + + gomp_clear_parent (&child_task->children_queue); + + gomp_task_run_post_remove_taskgroup (child_task); + + to_free = child_task; + child_task = NULL; + team->task_count--; + if (new_tasks > 1) + { + do_wake = team->nthreads - team->task_running_count + - !task->in_tied_task; + if (do_wake > new_tasks) + do_wake = new_tasks; + } + } + } + } + + /* An undeferred task is about to run. Wait for all tasks that this + undeferred task depends on. + + This is done by first putting all known ready dependencies + (dependencies that have their own dependencies met) at the top of + the scheduling queues. Then we iterate through these imminently + ready tasks (and possibly other high priority tasks), and run them. + If we run out of ready dependencies to execute, we either wait for + the reamining dependencies to finish, or wait for them to get + scheduled so we can run them. + + DEPEND is as in GOMP_task. */ + + void + gomp_task_maybe_wait_for_dependencies (void **depend) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_task *task = thr->task; + struct gomp_team *team = thr->ts.team; + struct gomp_task_depend_entry elem, *ent = NULL; + struct gomp_taskwait taskwait; + size_t ndepend = (uintptr_t) depend[0]; + size_t nout = (uintptr_t) depend[1]; + size_t i; + size_t num_awaited = 0; + struct gomp_task *child_task = NULL; + struct gomp_task *to_free = NULL; + int do_wake = 0; + + gomp_mutex_lock (&team->task_lock); + for (i = 0; i < ndepend; i++) + { + elem.addr = depend[i + 2]; + ent = htab_find (task->depend_hash, &elem); + for (; ent; ent = ent->next) + if (i >= nout && ent->is_in) + continue; + else + { + struct gomp_task *tsk = ent->task; + if (!tsk->parent_depends_on) + { + tsk->parent_depends_on = true; + ++num_awaited; + /* If depenency TSK itself has no dependencies and is + ready to run, move it up front so that we run it as + soon as possible. */ + if (tsk->num_dependees == 0 && tsk->kind == GOMP_TASK_WAITING) + priority_queue_upgrade_task (tsk, task); + } + } + } + if (num_awaited == 0) + { + gomp_mutex_unlock (&team->task_lock); + return; + } + + memset (&taskwait, 0, sizeof (taskwait)); + taskwait.n_depend = num_awaited; + gomp_sem_init (&taskwait.taskwait_sem, 0); + task->taskwait = &taskwait; + + while (1) + { + bool cancelled = false; + if (taskwait.n_depend == 0) + { + task->taskwait = NULL; + gomp_mutex_unlock (&team->task_lock); + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + } + gomp_sem_destroy (&taskwait.taskwait_sem); + return; + } + + /* Theoretically when we have multiple priorities, we should + chose between the highest priority item in + task->children_queue and team->task_queue here, so we should + use priority_queue_next_task(). However, since we are + running an undeferred task, perhaps that makes all tasks it + depends on undeferred, thus a priority of INF? This would + make it unnecessary to take anything into account here, + but the dependencies. + + On the other hand, if we want to use priority_queue_next_task(), + care should be taken to only use priority_queue_remove() + below if the task was actually removed from the children + queue. */ + bool ignored; + struct gomp_task *next_task + = priority_queue_next_task (PQ_CHILDREN, &task->children_queue, + PQ_IGNORED, NULL, &ignored); + + if (next_task->kind == GOMP_TASK_WAITING) + { + child_task = next_task; + cancelled + = gomp_task_run_pre (child_task, task, team); + if (__builtin_expect (cancelled, 0)) + { + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + goto finish_cancelled; + } + } + else + /* All tasks we are waiting for are either running in other + threads, or they are tasks that have not had their + dependencies met (so they're not even in the queue). Wait + for them. */ + taskwait.in_depend_wait = true; + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + { + gomp_team_barrier_wake (&team->barrier, do_wake); + do_wake = 0; + } + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + if (child_task) + { + thr->task = child_task; + if (__builtin_expect (child_task->fn == NULL, 0)) + { + if (gomp_target_task_fn (child_task->fn_data)) + { + thr->task = task; + gomp_mutex_lock (&team->task_lock); + child_task->kind = GOMP_TASK_ASYNC_RUNNING; + struct gomp_target_task *ttask + = (struct gomp_target_task *) child_task->fn_data; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, child_task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + child_task = NULL; + continue; + } + } + else + child_task->fn (child_task->fn_data); + thr->task = task; + } + else + gomp_sem_wait (&taskwait.taskwait_sem); + gomp_mutex_lock (&team->task_lock); + if (child_task) + { + finish_cancelled:; + size_t new_tasks + = gomp_task_run_post_handle_depend (child_task, team); + if (child_task->parent_depends_on) + --taskwait.n_depend; + + priority_queue_remove (PQ_CHILDREN, &task->children_queue, + child_task, MEMMODEL_RELAXED); + child_task->pnode[PQ_CHILDREN].next = NULL; + child_task->pnode[PQ_CHILDREN].prev = NULL; + + gomp_clear_parent (&child_task->children_queue); + gomp_task_run_post_remove_taskgroup (child_task); + to_free = child_task; + child_task = NULL; + team->task_count--; + if (new_tasks > 1) + { + do_wake = team->nthreads - team->task_running_count + - !task->in_tied_task; + if (do_wake > new_tasks) + do_wake = new_tasks; + } + } + } + } + + /* Called when encountering a taskyield directive. */ + + void + GOMP_taskyield (void) + { + /* Nothing at the moment. */ + } + + void + GOMP_taskgroup_start (void) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + struct gomp_task *task = thr->task; + struct gomp_taskgroup *taskgroup; + + /* If team is NULL, all tasks are executed as + GOMP_TASK_UNDEFERRED tasks and thus all children tasks of + taskgroup and their descendant tasks will be finished + by the time GOMP_taskgroup_end is called. */ + if (team == NULL) + return; + taskgroup = gomp_malloc (sizeof (struct gomp_taskgroup)); + taskgroup->prev = task->taskgroup; + priority_queue_init (&taskgroup->taskgroup_queue); + taskgroup->in_taskgroup_wait = false; + taskgroup->cancelled = false; + taskgroup->num_children = 0; + gomp_sem_init (&taskgroup->taskgroup_sem, 0); + task->taskgroup = taskgroup; + } + + void + GOMP_taskgroup_end (void) + { + struct gomp_thread *thr = gomp_thread (); + struct gomp_team *team = thr->ts.team; + struct gomp_task *task = thr->task; + struct gomp_taskgroup *taskgroup; + struct gomp_task *child_task = NULL; + struct gomp_task *to_free = NULL; + int do_wake = 0; + + if (team == NULL) + return; + taskgroup = task->taskgroup; + if (__builtin_expect (taskgroup == NULL, 0) + && thr->ts.level == 0) + { + /* This can happen if GOMP_taskgroup_start is called when + thr->ts.team == NULL, but inside of the taskgroup there + is #pragma omp target nowait that creates an implicit + team with a single thread. In this case, we want to wait + for all outstanding tasks in this team. */ + gomp_team_barrier_wait (&team->barrier); + return; + } + + /* The acquire barrier on load of taskgroup->num_children here + synchronizes with the write of 0 in gomp_task_run_post_remove_taskgroup. + It is not necessary that we synchronize with other non-0 writes at + this point, but we must ensure that all writes to memory by a + child thread task work function are seen before we exit from + GOMP_taskgroup_end. */ + if (__atomic_load_n (&taskgroup->num_children, MEMMODEL_ACQUIRE) == 0) + goto finish; + + bool unused; + gomp_mutex_lock (&team->task_lock); + while (1) + { + bool cancelled = false; + if (priority_queue_empty_p (&taskgroup->taskgroup_queue, + MEMMODEL_RELAXED)) + { + if (taskgroup->num_children) + { + if (priority_queue_empty_p (&task->children_queue, + MEMMODEL_RELAXED)) + goto do_wait; + child_task + = priority_queue_next_task (PQ_CHILDREN, &task->children_queue, + PQ_TEAM, &team->task_queue, + &unused); + } + else + { + gomp_mutex_unlock (&team->task_lock); + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + } + goto finish; + } + } + else + child_task + = priority_queue_next_task (PQ_TASKGROUP, &taskgroup->taskgroup_queue, + PQ_TEAM, &team->task_queue, &unused); + if (child_task->kind == GOMP_TASK_WAITING) + { + cancelled + = gomp_task_run_pre (child_task, child_task->parent, team); + if (__builtin_expect (cancelled, 0)) + { + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + goto finish_cancelled; + } + } + else + { + child_task = NULL; + do_wait: + /* All tasks we are waiting for are either running in other + threads, or they are tasks that have not had their + dependencies met (so they're not even in the queue). Wait + for them. */ + taskgroup->in_taskgroup_wait = true; + } + gomp_mutex_unlock (&team->task_lock); + if (do_wake) + { + gomp_team_barrier_wake (&team->barrier, do_wake); + do_wake = 0; + } + if (to_free) + { + gomp_finish_task (to_free); + free (to_free); + to_free = NULL; + } + if (child_task) + { + thr->task = child_task; + if (__builtin_expect (child_task->fn == NULL, 0)) + { + if (gomp_target_task_fn (child_task->fn_data)) + { + thr->task = task; + gomp_mutex_lock (&team->task_lock); + child_task->kind = GOMP_TASK_ASYNC_RUNNING; + struct gomp_target_task *ttask + = (struct gomp_target_task *) child_task->fn_data; + /* If GOMP_PLUGIN_target_task_completion has run already + in between gomp_target_task_fn and the mutex lock, + perform the requeuing here. */ + if (ttask->state == GOMP_TARGET_TASK_FINISHED) + gomp_target_task_completion (team, child_task); + else + ttask->state = GOMP_TARGET_TASK_RUNNING; + child_task = NULL; + continue; + } + } + else + child_task->fn (child_task->fn_data); + thr->task = task; + } + else + gomp_sem_wait (&taskgroup->taskgroup_sem); + gomp_mutex_lock (&team->task_lock); + if (child_task) + { + finish_cancelled:; + size_t new_tasks + = gomp_task_run_post_handle_depend (child_task, team); + gomp_task_run_post_remove_parent (child_task); + gomp_clear_parent (&child_task->children_queue); + gomp_task_run_post_remove_taskgroup (child_task); + to_free = child_task; + child_task = NULL; + team->task_count--; + if (new_tasks > 1) + { + do_wake = team->nthreads - team->task_running_count + - !task->in_tied_task; + if (do_wake > new_tasks) + do_wake = new_tasks; + } + } + } + + finish: + task->taskgroup = taskgroup->prev; + gomp_sem_destroy (&taskgroup->taskgroup_sem); + free (taskgroup); + } + + int + omp_in_final (void) + { + struct gomp_thread *thr = gomp_thread (); + return thr->task && thr->task->final_task; + } + + ialias (omp_in_final) diff --git a/libgomp_taskgraph/.gitignore b/libgomp_taskgraph/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/libgomp_taskgraph/.tags b/libgomp_taskgraph/.tags new file mode 100644 index 0000000000000000000000000000000000000000..0a4c2a2a217cad15de9d38f5ba86d863048d78e3 --- /dev/null +++ b/libgomp_taskgraph/.tags @@ -0,0 +1,9521 @@ +!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ +!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ +!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ +!_TAG_PROGRAM_NAME Exuberant Ctags // +!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ +!_TAG_PROGRAM_VERSION 5.9~svn20110310 // +10 testsuite/libgomp.fortran/omp_atomic2.f90 /^10 d(i) = 21 - i$/;" l file: +10 testsuite/libgomp.fortran/omp_cond1.f /^ 10 foo = 2$/;" l file: +10 testsuite/libgomp.fortran/omp_cond2.f /^ 10 foo = 2$/;" l file: +10 testsuite/libgomp.fortran/omp_cond3.F90 /^ 10 foo = 2&$/;" l file: +10 testsuite/libgomp.fortran/omp_cond4.F90 /^ 10 foo = 2&$/;" l file: +100 testsuite/libgomp.fortran/appendix-a/a.4.1.f90 /^ 100 CONTINUE$/;" l subroutine:SUBDOMAIN file: +100 testsuite/libgomp.fortran/omp_parse3.f90 /^100 d(i) = -1$/;" l subroutine:test_ordered file: +100 testsuite/libgomp.fortran/omp_workshare1.f /^ 100 FORMAT(' Thread',I2,': C(',I3,')=',F8.2)$/;" l program:WORKSHARE1 file: +100 testsuite/libgomp.fortran/omp_workshare2.f /^ 100 FORMAT(' Thread',I2,': C(',I2,')=',F8.2)$/;" l program:WORKSHARE2 file: +100 testsuite/libgomp.fortran/task2.f90 /^100 continue$/;" l subroutine:foo file: +100 testsuite/libgomp.fortran/vla1.f90 /^100 continue$/;" l subroutine:foo file: +100 testsuite/libgomp.fortran/vla3.f90 /^100 continue$/;" l subroutine:foo file: +100 testsuite/libgomp.fortran/vla4.f90 /^100 continue$/;" l subroutine:foo file: +101 testsuite/libgomp.fortran/task2.f90 /^101 continue$/;" l subroutine:foo file: +101 testsuite/libgomp.fortran/vla1.f90 /^101 continue$/;" l subroutine:foo file: +101 testsuite/libgomp.fortran/vla3.f90 /^101 continue$/;" l subroutine:foo file: +101 testsuite/libgomp.fortran/vla4.f90 /^101 continue$/;" l subroutine:foo file: +102 testsuite/libgomp.fortran/task2.f90 /^102 continue$/;" l subroutine:foo file: +102 testsuite/libgomp.fortran/vla1.f90 /^102 continue$/;" l subroutine:foo file: +102 testsuite/libgomp.fortran/vla3.f90 /^102 continue$/;" l subroutine:foo file: +102 testsuite/libgomp.fortran/vla4.f90 /^102 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla1.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla2.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla3.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla4.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla5.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla6.f90 /^103 continue$/;" l subroutine:foo file: +103 testsuite/libgomp.fortran/vla8.f90 /^103 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla1.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla2.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla3.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla4.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla5.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla6.f90 /^104 continue$/;" l subroutine:foo file: +104 testsuite/libgomp.fortran/vla8.f90 /^104 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla1.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla2.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla3.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla4.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla5.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla6.f90 /^105 continue$/;" l subroutine:foo file: +105 testsuite/libgomp.fortran/vla8.f90 /^105 continue$/;" l subroutine:foo file: +110 testsuite/libgomp.fortran/vla3.f90 /^110 continue$/;" l subroutine:foo file: +110 testsuite/libgomp.fortran/vla4.f90 /^110 continue$/;" l subroutine:foo file: +110 testsuite/libgomp.fortran/vla5.f90 /^110 continue$/;" l subroutine:foo file: +113 testsuite/libgomp.fortran/vla4.f90 /^113 continue$/;" l subroutine:foo file: +113 testsuite/libgomp.fortran/vla5.f90 /^113 continue$/;" l subroutine:foo file: +113 testsuite/libgomp.fortran/vla6.f90 /^113 continue$/;" l subroutine:foo file: +113 testsuite/libgomp.fortran/vla8.f90 /^113 continue$/;" l subroutine:foo file: +114 testsuite/libgomp.fortran/vla4.f90 /^114 continue$/;" l subroutine:foo file: +114 testsuite/libgomp.fortran/vla5.f90 /^114 continue$/;" l subroutine:foo file: +114 testsuite/libgomp.fortran/vla6.f90 /^114 continue$/;" l subroutine:foo file: +114 testsuite/libgomp.fortran/vla8.f90 /^114 continue$/;" l subroutine:foo file: +115 testsuite/libgomp.fortran/collapse2.f90 /^115 continue$/;" l subroutine:test2 file: +115 testsuite/libgomp.fortran/vla4.f90 /^115 continue$/;" l subroutine:foo file: +115 testsuite/libgomp.fortran/vla5.f90 /^115 continue$/;" l subroutine:foo file: +115 testsuite/libgomp.fortran/vla6.f90 /^115 continue$/;" l subroutine:foo file: +115 testsuite/libgomp.fortran/vla8.f90 /^115 continue$/;" l subroutine:foo file: +115 testsuite/libgomp.oacc-fortran/collapse-3.f90 /^115 continue$/;" l program:collapse3 file: +115 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^115 continue$/;" l subroutine:test2 file: +115 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^115 continue$/;" l subroutine:test1 file: +115 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^115 continue$/;" l subroutine:test1 file: +120 testsuite/libgomp.fortran/collapse2.f90 /^120 end do dol$/;" l subroutine:test2 file: +120 testsuite/libgomp.oacc-fortran/collapse-3.f90 /^120 end do dol$/;" l program:collapse3 file: +120 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^120 end do dol$/;" l subroutine:test2 file: +120 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^120 end do dol$/;" l subroutine:test1 file: +120 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^120 end do dol$/;" l subroutine:test1 file: +123 testsuite/libgomp.fortran/vla8.f90 /^123 continue$/;" l subroutine:foo file: +124 testsuite/libgomp.fortran/vla8.f90 /^124 continue$/;" l subroutine:foo file: +125 testsuite/libgomp.fortran/vla8.f90 /^125 continue$/;" l subroutine:foo file: +164 testsuite/libgomp.fortran/collapse2.f90 /^164 end do$/;" l subroutine:test1 file: +164 testsuite/libgomp.oacc-fortran/collapse-2.f90 /^164 end do$/;" l program:collapse2 file: +164 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^164 end do$/;" l subroutine:test1 file: +200 testsuite/libgomp.fortran/omp_parse1.f90 /^200 d(n) = omp_get_thread_num ()$/;" l subroutine:test_do file: +201 testsuite/libgomp.fortran/omp_parse1.f90 /^201 d(i) = omp_get_thread_num () + 1024$/;" l subroutine:test_do file: +600 testsuite/libgomp.fortran/omp_parse1.f90 /^600 l = k$/;" l subroutine:test_do_orphan file: +A testsuite/libgomp.c++/ctor-12.C /^ A ()$/;" f struct:A +A testsuite/libgomp.c++/ctor-12.C /^ A (const A &x)$/;" f struct:A +A testsuite/libgomp.c++/ctor-12.C /^struct A$/;" s file: +A testsuite/libgomp.c++/member-1.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-1.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/member-2.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-2.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/member-3.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-3.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/member-4.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-4.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/member-5.C /^struct A : public R, virtual public T { A () {} I a; void m1 (const I &, const I &); };$/;" f struct:A +A testsuite/libgomp.c++/member-5.C /^struct A : public R, virtual public T { A () {} I a; void m1 (const I &, const I &); };$/;" s file: +A testsuite/libgomp.c++/member-6.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-6.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/member-7.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" f struct:A +A testsuite/libgomp.c++/member-7.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" s file: +A testsuite/libgomp.c++/pr26691.C /^ A (int i = 3) : n (i) {}$/;" f struct:A +A testsuite/libgomp.c++/pr26691.C /^struct A$/;" s file: +A testsuite/libgomp.c++/pr30703.C /^A::A()$/;" f class:A +A testsuite/libgomp.c++/pr30703.C /^A::A(const A &r)$/;" f class:A +A testsuite/libgomp.c++/pr30703.C /^struct A$/;" s file: +A testsuite/libgomp.c++/pr48869.C /^ A () {}$/;" f struct:A +A testsuite/libgomp.c++/pr48869.C /^struct A$/;" s file: +A testsuite/libgomp.c++/pr70376.C /^ A() { }$/;" f struct:A +A testsuite/libgomp.c++/pr70376.C /^ A(const A&) { }$/;" f struct:A +A testsuite/libgomp.c++/pr70376.C /^struct A$/;" s file: +A testsuite/libgomp.c++/pr81130.C /^A::A ()$/;" f class:A +A testsuite/libgomp.c++/pr81130.C /^struct A$/;" s file: +A testsuite/libgomp.c++/reduction-10.C /^ A () { t = 0; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-10.C /^ A (T x) { t = x; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-10.C /^ A (const A &x) { t = x.t; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-10.C /^struct A$/;" s file: +A testsuite/libgomp.c++/reduction-12.C /^ A () { t = 0; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-12.C /^ A (T x) { t = x; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-12.C /^ A (const A &x) { t = x.t; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-12.C /^struct A$/;" s file: +A testsuite/libgomp.c++/reduction-6.C /^ A () { t = 0; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-6.C /^ A (T x) { t = x; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-6.C /^ A (const A &x) { t = x.t; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-6.C /^struct A$/;" s file: +A testsuite/libgomp.c++/reduction-8.C /^ A () { t = 0; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-8.C /^ A (T x) { t = x; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-8.C /^ A (const A &x) { t = x.t; }$/;" f struct:A +A testsuite/libgomp.c++/reduction-8.C /^struct A$/;" s file: +A testsuite/libgomp.c++/task-3.C /^A::A ()$/;" f class:A +A testsuite/libgomp.c++/task-3.C /^A::A (const A &r)$/;" f class:A +A testsuite/libgomp.c++/task-3.C /^struct A$/;" s file: +A testsuite/libgomp.c++/task-5.C /^A::A ()$/;" f class:A +A testsuite/libgomp.c++/task-5.C /^A::A (const A &r)$/;" f class:A +A testsuite/libgomp.c++/task-5.C /^struct A$/;" s file: +A testsuite/libgomp.c++/task-7.C /^ A() { }$/;" f struct:A +A testsuite/libgomp.c++/task-7.C /^ A(const A&) { }$/;" f struct:A +A testsuite/libgomp.c++/task-7.C /^struct A$/;" s file: +A testsuite/libgomp.c++/tls-init1.C /^A::A(): i(j) { }$/;" f class:A +A testsuite/libgomp.c++/tls-init1.C /^struct A$/;" s file: +A testsuite/libgomp.c++/udr-6.C /^ struct A { int a; A () : a (0) {} };$/;" f struct:N1::A +A testsuite/libgomp.c++/udr-6.C /^ struct A { int a; A () : a (0) {} };$/;" s namespace:N1 file: +A testsuite/libgomp.c++/udr-6.C /^struct A { int a; A () : a (6) {} };$/;" f struct:A +A testsuite/libgomp.c++/udr-6.C /^struct A { int a; A () : a (6) {} };$/;" s file: +A testsuite/libgomp.c/appendix-a/a.29.1.c /^int A[2][2] = { 1, 2, 3, 4 };$/;" v +A testsuite/libgomp.c/doacross-1.c 76;" d file: +A testsuite/libgomp.c/doacross-1.c 81;" d file: +A testsuite/libgomp.c/doacross-1.c 86;" d file: +A testsuite/libgomp.c/doacross-1.c 88;" d file: +A testsuite/libgomp.c/doacross-1.c 92;" d file: +A testsuite/libgomp.c/doacross-2.c 78;" d file: +A testsuite/libgomp.c/doacross-2.c 83;" d file: +A testsuite/libgomp.c/doacross-2.c 88;" d file: +A testsuite/libgomp.c/doacross-2.c 90;" d file: +A testsuite/libgomp.c/doacross-2.c 94;" d file: +A testsuite/libgomp.c/doacross-3.c 78;" d file: +A testsuite/libgomp.c/doacross-3.c 83;" d file: +A testsuite/libgomp.c/doacross-3.c 88;" d file: +A testsuite/libgomp.c/doacross-3.c 90;" d file: +A testsuite/libgomp.c/doacross-3.c 94;" d file: +A testsuite/libgomp.c/examples-4/simd-8.c /^float A[1000];$/;" v +A testsuite/libgomp.c/reduction-10.c /^struct A { int t; };$/;" s file: +A testsuite/libgomp.c/reduction-12.c /^struct A { int t; };$/;" s file: +A testsuite/libgomp.c/reduction-14.c /^struct A { int t; };$/;" s file: +A testsuite/libgomp.c/reduction-8.c /^struct A { int t; };$/;" s file: +A testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ INTEGER, AL/;" v program:A22_7_GOOD +A testsuite/libgomp.fortran/appendix-a/a.28.4.f90 /^ INTEGER A(/;" v program:A28_4 +A testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ INTEGER A$/;" k type:LOCKED_PAIR +A testsuite/libgomp.fortran/examples-4/simd-8.f90 /^real :: A(/;" v module:work +A testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ real, dimension(32, 32) :: A,/;" v program:main +A testsuite/libgomp.fortran/omp_orphan.f /^ REAL/;" v program:ORPHAN +A testsuite/libgomp.fortran/omp_reduction.f /^ REAL/;" v program:REDUCTION +A testsuite/libgomp.fortran/omp_workshare1.f /^ REAL/;" v program:WORKSHARE1 +A testsuite/libgomp.fortran/omp_workshare2.f /^ REAL/;" v program:WORKSHARE2 +A testsuite/libgomp.fortran/strassen.f90 /^ double precision, save :: A(/;" v program:strassen_matmul +A testsuite/libgomp.graphite/force-parallel-6.c /^int A[2*N][2*N], C[2*N][2*N];$/;" v +A testsuite/libgomp.graphite/force-parallel-7.c /^int A[N+5][N+5][N+5];$/;" v +A testsuite/libgomp.oacc-c-c++-common/deviceptr-1.c 7;" d file: +A testsuite/libgomp.oacc-c-c++-common/reduction-initial-1.c 8;" d file: +A10 testsuite/libgomp.fortran/appendix-a/a10.1.f90 /^ PROGRAM A10$/;" p +A15 testsuite/libgomp.fortran/appendix-a/a.15.1.f90 /^ PROGRAM A15$/;" p +A16 testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ PROGRAM A16$/;" p +A18 testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ PROGRAM A18$/;" p +A19 testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ PROGRAM A19$/;" p +A2 testsuite/libgomp.fortran/appendix-a/a.2.1.f90 /^PROGRAM A2$/;" p +A21 testsuite/libgomp.fortran/appendix-a/a.21.1.f90 /^ PROGRAM A21$/;" p +A22_7_GOOD testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ PROGRAM A22_7_GOOD$/;" p +A22_8_GOOD testsuite/libgomp.fortran/appendix-a/a.22.8.f90 /^ PROGRAM A22_8_GOOD$/;" p +A22_MODULE8 testsuite/libgomp.fortran/appendix-a/a.22.8.f90 /^ MODULE A22_MODULE8$/;" m +A26 testsuite/libgomp.fortran/appendix-a/a.26.1.f90 /^ PROGRAM A26$/;" p +A28_1 testsuite/libgomp.fortran/appendix-a/a.28.1.f90 /^ PROGRAM A28_1$/;" p +A28_2 testsuite/libgomp.fortran/appendix-a/a.28.2.f90 /^ PROGRAM A28_2$/;" p +A28_3 testsuite/libgomp.fortran/appendix-a/a.28.3.f90 /^ PROGRAM A28_3$/;" p +A28_4 testsuite/libgomp.fortran/appendix-a/a.28.4.f90 /^ PROGRAM A28_4$/;" p +A28_5 testsuite/libgomp.fortran/appendix-a/a.28.5.f90 /^ PROGRAM A28_5$/;" p +A3 testsuite/libgomp.fortran/appendix-a/a.3.1.f90 /^ PROGRAM A3$/;" p +A31_4 testsuite/libgomp.fortran/appendix-a/a.31.4.f90 /^ PROGRAM A31_4$/;" p +A31_5 testsuite/libgomp.fortran/appendix-a/a.31.5.f90 /^ PROGRAM A31_5$/;" p +A39 testsuite/libgomp.fortran/appendix-a/a.39.1.f90 /^ PROGRAM A39$/;" p +A4 testsuite/libgomp.fortran/appendix-a/a.4.1.f90 /^ PROGRAM A4$/;" p +A40 testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ SUBROUTINE A40(/;" s +A5 testsuite/libgomp.fortran/appendix-a/a.5.1.f90 /^ PROGRAM A5$/;" p +ACTUAL_GANGS testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 795;" d file: +ACTUAL_GANGS testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 834;" d file: +ACTUAL_GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c 7;" d file: +ARRAY testsuite/libgomp.fortran/appendix-a/a.4.1.f90 /^ REAL ARRAY(/;" v program:A4 +ASSERT testsuite/libgomp.hsa.c/builtins-1.c 54;" d file: +ASSERT_SX testsuite/libgomp.hsa.c/bitfield-1.c 15;" d file: +ASSIGN_SX testsuite/libgomp.hsa.c/bitfield-1.c 3;" d file: +B testsuite/libgomp.c++/ctor-1.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-1.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-10.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-10.C /^B::B(const B &b)$/;" f class:B +B testsuite/libgomp.c++/ctor-10.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-11.C /^B::B ()$/;" f class:B +B testsuite/libgomp.c++/ctor-11.C /^B::B (const B &)$/;" f class:B +B testsuite/libgomp.c++/ctor-11.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-13.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-13.C /^B::B(const B &)$/;" f class:B +B testsuite/libgomp.c++/ctor-13.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-2.C /^B::B(const B &b)$/;" f class:B +B testsuite/libgomp.c++/ctor-2.C /^B::B(int)$/;" f class:B +B testsuite/libgomp.c++/ctor-2.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-3.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-3.C /^B::B(int)$/;" f class:B +B testsuite/libgomp.c++/ctor-3.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-4.C /^B::B(const B &b)$/;" f class:B +B testsuite/libgomp.c++/ctor-4.C /^B::B(int)$/;" f class:B +B testsuite/libgomp.c++/ctor-4.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-5.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-6.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-7.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-7.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-8.C /^B::B()$/;" f class:B +B testsuite/libgomp.c++/ctor-8.C /^B::B(const B &b)$/;" f class:B +B testsuite/libgomp.c++/ctor-8.C /^struct B$/;" s file: +B testsuite/libgomp.c++/ctor-9.C /^struct B$/;" s file: +B testsuite/libgomp.c++/member-5.C /^struct B : public R, virtual public U { B () {} Q a; void m2 (const Q &, const Q &, const I &, const I &); };$/;" f struct:B +B testsuite/libgomp.c++/member-5.C /^struct B : public R, virtual public U { B () {} Q a; void m2 (const Q &, const Q &, const I &, const I &); };$/;" s file: +B testsuite/libgomp.c++/pr48869.C /^ B () {}$/;" f struct:B +B testsuite/libgomp.c++/pr48869.C /^ B (const B&) {}$/;" f struct:B +B testsuite/libgomp.c++/pr48869.C /^struct B$/;" s file: +B testsuite/libgomp.c++/pr81130.C /^ B () : c (1)$/;" f struct:B +B testsuite/libgomp.c++/pr81130.C /^struct B$/;" s file: +B testsuite/libgomp.c++/reduction-10.C /^ B () { t = ~(T) 0; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-10.C /^ B (T x) { t = x; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-10.C /^ B (const B &x) { t = x.t; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-10.C /^struct B$/;" s file: +B testsuite/libgomp.c++/reduction-12.C /^ B () { t = ~(T) 0; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-12.C /^ B (T x) { t = x; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-12.C /^ B (const B &x) { t = x.t; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-12.C /^struct B$/;" s file: +B testsuite/libgomp.c++/reduction-6.C /^ B () { t = ~(T) 0; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-6.C /^ B (T x) { t = x; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-6.C /^ B (const B &x) { t = x.t; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-6.C /^struct B$/;" s file: +B testsuite/libgomp.c++/reduction-8.C /^ B () { t = ~(T) 0; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-8.C /^ B (T x) { t = x; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-8.C /^ B (const B &x) { t = x.t; }$/;" f struct:B +B testsuite/libgomp.c++/reduction-8.C /^struct B$/;" s file: +B testsuite/libgomp.c++/udr-6.C /^ struct B : N1::A { };$/;" s namespace:N2 file: +B testsuite/libgomp.c++/udr-6.C /^struct B { int b; B () : b (5) {} };$/;" f struct:B +B testsuite/libgomp.c++/udr-6.C /^struct B { int b; B () : b (5) {} };$/;" s file: +B testsuite/libgomp.c/doacross-1.c 77;" d file: +B testsuite/libgomp.c/doacross-2.c 79;" d file: +B testsuite/libgomp.c/doacross-3.c 79;" d file: +B testsuite/libgomp.c/reduction-10.c /^struct B { char t; };$/;" s file: +B testsuite/libgomp.c/reduction-12.c /^struct B { char t; };$/;" s file: +B testsuite/libgomp.c/reduction-14.c /^struct B { char t; };$/;" s file: +B testsuite/libgomp.c/reduction-8.c /^struct B { char t; };$/;" s file: +B testsuite/libgomp.fortran/appendix-a/a.28.4.f90 /^ INTEGER A(100), B(/;" v program:A28_4 +B testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ INTEGER B$/;" k type:LOCKED_PAIR +B testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ real, dimension(32, 32) :: A, B,/;" v program:main +B testsuite/libgomp.fortran/examples-4/teams-2.f90 /^ real, pointer, dimension(:) :: B,/;" v program:e_54_1 +B testsuite/libgomp.fortran/examples-4/teams-3.f90 /^ real, pointer, dimension(:) :: B,/;" v program:e_54_3 +B testsuite/libgomp.fortran/examples-4/teams-4.f90 /^ real, pointer, dimension(:) :: B,/;" v program:e_54_4 +B testsuite/libgomp.fortran/omp_orphan.f /^ REAL*8 A(VECLEN), B(/;" v program:ORPHAN +B testsuite/libgomp.fortran/omp_reduction.f /^ REAL A(100), B(/;" v program:REDUCTION +B testsuite/libgomp.fortran/omp_workshare1.f /^ REAL A(N), B(/;" v program:WORKSHARE1 +B testsuite/libgomp.fortran/omp_workshare2.f /^ REAL A(N), B(/;" v program:WORKSHARE2 +B testsuite/libgomp.fortran/strassen.f90 /^ double precision, save :: A(N,N), B(/;" v program:strassen_matmul +B testsuite/libgomp.graphite/force-parallel-3.c /^int Z[2*N+2][2*N+2], B[2*N+2][2*N+2];$/;" v +B testsuite/libgomp.graphite/force-parallel-6.c /^int X[2*N], Y[2*N], B[2*N];$/;" v +B testsuite/libgomp.graphite/force-parallel-9.c /^int Z[2*N+2][2*N+2], B[2*N+2][2*N+2];$/;" v +BAR_CANCELLED config/linux/bar.h 53;" d +BAR_CANCELLED config/nvptx/bar.h 51;" d +BAR_CANCELLED config/posix/bar.h 58;" d +BAR_CANCELLED config/rtems/bar.h 54;" d +BAR_INCR config/linux/bar.h 54;" d +BAR_INCR config/nvptx/bar.h 52;" d +BAR_INCR config/posix/bar.h 59;" d +BAR_INCR config/rtems/bar.h 55;" d +BAR_TASK_PENDING config/linux/bar.h 50;" d +BAR_TASK_PENDING config/nvptx/bar.h 48;" d +BAR_TASK_PENDING config/posix/bar.h 55;" d +BAR_TASK_PENDING config/rtems/bar.h 51;" d +BAR_WAITING_FOR_TASK config/linux/bar.h 52;" d +BAR_WAITING_FOR_TASK config/nvptx/bar.h 50;" d +BAR_WAITING_FOR_TASK config/posix/bar.h 57;" d +BAR_WAITING_FOR_TASK config/rtems/bar.h 53;" d +BAR_WAS_LAST config/linux/bar.h 51;" d +BAR_WAS_LAST config/nvptx/bar.h 49;" d +BAR_WAS_LAST config/posix/bar.h 56;" d +BAR_WAS_LAST config/rtems/bar.h 52;" d +BITSIZE testsuite/libgomp.hsa.c/rotate-1.c 5;" d file: +BLOCK2 testsuite/libgomp.fortran/appendix-a/a.28.2.f90 12;" c subroutine:SUB +BLOCK2 testsuite/libgomp.fortran/appendix-a/a.28.2.f90 4;" c program:A28_2 +BLOCK5 testsuite/libgomp.fortran/appendix-a/a.28.5.f90 18;" c program:A28_5 +BLOCK_SIZE testsuite/libgomp.hsa.c/tiling-1.c 10;" d file: +BLOCK_SIZE testsuite/libgomp.hsa.c/tiling-2.c 10;" d file: +BS testsuite/libgomp.c/examples-4/task_dep-5.c 4;" d file: +BrigModule_t plugin/hsa_ext_finalize.h /^typedef struct BrigModuleHeader *BrigModule_t;$/;" t typeref:struct:BrigModuleHeader +C testsuite/libgomp.c++/udr-6.C /^struct C { int c; C () : c (4) {} };$/;" f struct:C +C testsuite/libgomp.c++/udr-6.C /^struct C { int c; C () : c (4) {} };$/;" s file: +C testsuite/libgomp.c/doacross-1.c 78;" d file: +C testsuite/libgomp.c/doacross-2.c 80;" d file: +C testsuite/libgomp.c/doacross-3.c 80;" d file: +C testsuite/libgomp.c/reduction-10.c /^struct C { unsigned long long t; };$/;" s file: +C testsuite/libgomp.c/reduction-12.c /^struct C { unsigned long long t; };$/;" s file: +C testsuite/libgomp.c/reduction-14.c /^struct C { unsigned long long t; };$/;" s file: +C testsuite/libgomp.c/reduction-8.c /^struct C { unsigned long long t; };$/;" s file: +C testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ real, dimension(32, 32) :: A, B, C,/;" v program:main +C testsuite/libgomp.fortran/examples-4/teams-2.f90 /^ real, pointer, dimension(:) :: B, C$/;" v program:e_54_1 +C testsuite/libgomp.fortran/examples-4/teams-3.f90 /^ real, pointer, dimension(:) :: B, C$/;" v program:e_54_3 +C testsuite/libgomp.fortran/examples-4/teams-4.f90 /^ real, pointer, dimension(:) :: B, C$/;" v program:e_54_4 +C testsuite/libgomp.fortran/omp_workshare1.f /^ REAL A(N), B(N), C(/;" v program:WORKSHARE1 +C testsuite/libgomp.fortran/omp_workshare2.f /^ REAL A(N), B(N), C(/;" v program:WORKSHARE2 +C testsuite/libgomp.fortran/strassen.f90 /^ double precision, save :: A(N,N), B(N,N), C(/;" v program:strassen_matmul +C testsuite/libgomp.graphite/force-parallel-6.c /^int A[2*N][2*N], C[2*N][2*N];$/;" v +C testsuite/libgomp.hsa.c/complex-1.c 6;" d file: +C testsuite/libgomp.hsa.c/memory-operations-1.c 3;" d file: +C1 testsuite/libgomp.hsa.c/rotate-1.c 7;" d file: +CHUNK testsuite/libgomp.c/loop-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +CHUNK testsuite/libgomp.c/loop-2.c /^static int INCR, NTHR, CHUNK;$/;" v file: +CHUNK testsuite/libgomp.c/ordered-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +CHUNK testsuite/libgomp.c/ordered-2.c /^static int CHUNK, NTHR;$/;" v file: +CHUNK testsuite/libgomp.fortran/omp_workshare1.f /^ + OMP_GET_THREAD_NUM, N, CHUNKS/;" v program:WORKSHARE1 +CHUNKSIZE testsuite/libgomp.c/omp_workshare1.c 14;" d file: +CHUNKSIZE testsuite/libgomp.c/omp_workshare3.c 17;" d file: +CHUNKSIZE testsuite/libgomp.c/omp_workshare4.c 16;" d file: +CHUNKSIZE testsuite/libgomp.fortran/omp_workshare1.f /^ + OMP_GET_THREAD_NUM, N, CHUNKSIZE,/;" v program:WORKSHARE1 +CHUNKSZ testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^ integer, parameter :: N = 100000, CHUNKSZ /;" v module:e_55_1_mod +COLS testsuite/libgomp.c/examples-4/target_data-3.c /^const int COLS = 5;$/;" v +CONSTRUCT testsuite/libgomp.oacc-c-c++-common/data-clauses-kernels.c 1;" d file: +CONSTRUCT testsuite/libgomp.oacc-c-c++-common/data-clauses-parallel.c 1;" d file: +COUNTERTYPE testsuite/libgomp.oacc-c-c++-common/kernels-loop-2.c 4;" d file: +COUNTERTYPE testsuite/libgomp.oacc-c-c++-common/kernels-loop-3.c 4;" d file: +COUNTERTYPE testsuite/libgomp.oacc-c-c++-common/kernels-loop-mod-not-zero.c 4;" d file: +COUNTERTYPE testsuite/libgomp.oacc-c-c++-common/kernels-loop-n.c 4;" d file: +COUNTERTYPE testsuite/libgomp.oacc-c-c++-common/kernels-loop.c 4;" d file: +CPU_CLR_S config/linux/affinity.c 45;" d file: +CPU_ISSET_S config/linux/affinity.c 42;" d file: +CPU_SET_S config/linux/affinity.c 44;" d file: +CPU_ZERO_S config/linux/affinity.c 43;" d file: +CUDA_CALL plugin/plugin-nvptx.c 157;" d file: +CUDA_CALLS plugin/plugin-nvptx.c 54;" d file: +CUDA_CALL_ASSERT plugin/plugin-nvptx.c 160;" d file: +CUDA_CALL_ERET plugin/plugin-nvptx.c 145;" d file: +CUDA_CALL_NOCHECK plugin/plugin-nvptx.c 171;" d file: +CUDA_CALL_PREFIX plugin/plugin-nvptx.c 135;" d file: +CUDA_CALL_PREFIX plugin/plugin-nvptx.c 137;" d file: +CUDA_ERROR_INVALID_CONTEXT plugin/cuda/cuda.h /^ CUDA_ERROR_INVALID_CONTEXT = 201,$/;" e enum:__anon1 +CUDA_ERROR_INVALID_VALUE plugin/cuda/cuda.h /^ CUDA_ERROR_INVALID_VALUE = 1,$/;" e enum:__anon1 +CUDA_ERROR_LAUNCH_FAILED plugin/cuda/cuda.h /^ CUDA_ERROR_LAUNCH_FAILED = 719$/;" e enum:__anon1 +CUDA_ERROR_NOT_FOUND plugin/cuda/cuda.h /^ CUDA_ERROR_NOT_FOUND = 500,$/;" e enum:__anon1 +CUDA_ERROR_NOT_READY plugin/cuda/cuda.h /^ CUDA_ERROR_NOT_READY = 600,$/;" e enum:__anon1 +CUDA_ERROR_OUT_OF_MEMORY plugin/cuda/cuda.h /^ CUDA_ERROR_OUT_OF_MEMORY = 2,$/;" e enum:__anon1 +CUDA_ONE_CALL plugin/plugin-nvptx.c 101;" d file: +CUDA_ONE_CALL plugin/plugin-nvptx.c 123;" d file: +CUDA_ONE_CALL plugin/plugin-nvptx.c 124;" d file: +CUDA_ONE_CALL plugin/plugin-nvptx.c 133;" d file: +CUDA_ONE_CALL_1 plugin/plugin-nvptx.c 125;" d file: +CUDA_ONE_CALL_1 plugin/plugin-nvptx.c 134;" d file: +CUDA_SUCCESS plugin/cuda/cuda.h /^ CUDA_SUCCESS = 0,$/;" e enum:__anon1 +CUDA_VERSION plugin/cuda/cuda.h 34;" d +CU_CTX_SCHED_AUTO plugin/cuda/cuda.h /^ CU_CTX_SCHED_AUTO = 0$/;" e enum:__anon7 +CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = 40,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = 19,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_CLOCK_RATE plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_CLOCK_RATE = 13,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_COMPUTE_MODE plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = 20,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_GPU_OVERLAP plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = 15,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_INTEGRATED plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_INTEGRATED = 18,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = 12,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = 82$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 1,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = 39,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16,$/;" e enum:__anon2 +CU_DEVICE_ATTRIBUTE_WARP_SIZE plugin/cuda/cuda.h /^ CU_DEVICE_ATTRIBUTE_WARP_SIZE = 10,$/;" e enum:__anon2 +CU_EVENT_DEFAULT plugin/cuda/cuda.h /^ CU_EVENT_DEFAULT = 0,$/;" e enum:__anon3 +CU_EVENT_DISABLE_TIMING plugin/cuda/cuda.h /^ CU_EVENT_DISABLE_TIMING = 2$/;" e enum:__anon3 +CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK plugin/cuda/cuda.h /^ CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0,$/;" e enum:__anon4 +CU_FUNC_ATTRIBUTE_NUM_REGS plugin/cuda/cuda.h /^ CU_FUNC_ATTRIBUTE_NUM_REGS = 4$/;" e enum:__anon4 +CU_JIT_ERROR_LOG_BUFFER plugin/cuda/cuda.h /^ CU_JIT_ERROR_LOG_BUFFER = 5,$/;" e enum:__anon5 +CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES plugin/cuda/cuda.h /^ CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6,$/;" e enum:__anon5 +CU_JIT_INFO_LOG_BUFFER plugin/cuda/cuda.h /^ CU_JIT_INFO_LOG_BUFFER = 3,$/;" e enum:__anon5 +CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES plugin/cuda/cuda.h /^ CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4,$/;" e enum:__anon5 +CU_JIT_INPUT_PTX plugin/cuda/cuda.h /^ CU_JIT_INPUT_PTX = 1$/;" e enum:__anon6 +CU_JIT_LOG_VERBOSE plugin/cuda/cuda.h /^ CU_JIT_LOG_VERBOSE = 12$/;" e enum:__anon5 +CU_JIT_WALL_TIME plugin/cuda/cuda.h /^ CU_JIT_WALL_TIME = 2,$/;" e enum:__anon5 +CU_LAUNCH_PARAM_BUFFER_POINTER plugin/cuda/cuda.h 103;" d +CU_LAUNCH_PARAM_BUFFER_SIZE plugin/cuda/cuda.h 104;" d +CU_LAUNCH_PARAM_END plugin/cuda/cuda.h 102;" d +CU_STREAM_DEFAULT plugin/cuda/cuda.h /^ CU_STREAM_DEFAULT = 0,$/;" e enum:__anon8 +CU_STREAM_NON_BLOCKING plugin/cuda/cuda.h /^ CU_STREAM_NON_BLOCKING = 1$/;" e enum:__anon8 +CUcontext plugin/cuda/cuda.h /^typedef void *CUcontext;$/;" t +CUdevice plugin/cuda/cuda.h /^typedef int CUdevice;$/;" t +CUdevice_attribute plugin/cuda/cuda.h /^} CUdevice_attribute;$/;" t typeref:enum:__anon2 +CUdeviceptr plugin/cuda/cuda.h /^typedef unsigned CUdeviceptr;$/;" t +CUdeviceptr plugin/cuda/cuda.h /^typedef unsigned long long CUdeviceptr;$/;" t +CUevent plugin/cuda/cuda.h /^typedef void *CUevent;$/;" t +CUfunction plugin/cuda/cuda.h /^typedef void *CUfunction;$/;" t +CUfunction_attribute plugin/cuda/cuda.h /^} CUfunction_attribute;$/;" t typeref:enum:__anon4 +CUjitInputType plugin/cuda/cuda.h /^} CUjitInputType;$/;" t typeref:enum:__anon6 +CUjit_option plugin/cuda/cuda.h /^} CUjit_option;$/;" t typeref:enum:__anon5 +CUlinkState plugin/cuda/cuda.h /^typedef void *CUlinkState;$/;" t +CUmodule plugin/cuda/cuda.h /^typedef void *CUmodule;$/;" t +CUresult plugin/cuda/cuda.h /^} CUresult;$/;" t typeref:enum:__anon1 +CUstream plugin/cuda/cuda.h /^typedef void *CUstream;$/;" t +C_ref testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ real, dimension(32, 32) :: A, B, C, C_ref$/;" v program:main +Cube testsuite/libgomp.hsa.c/formal-actual-args-1.c /^struct Cube$/;" s file: +D testsuite/libgomp.c++/udr-6.C /^struct D { int d; D () : d (3) {} };$/;" f struct:D +D testsuite/libgomp.c++/udr-6.C /^struct D { int d; D () : d (3) {} };$/;" s file: +D testsuite/libgomp.c/doacross-1.c 79;" d file: +D testsuite/libgomp.c/doacross-2.c 81;" d file: +D testsuite/libgomp.c/doacross-3.c 81;" d file: +D testsuite/libgomp.c/reduction-10.c /^struct D { long t; };$/;" s file: +D testsuite/libgomp.c/reduction-12.c /^struct D { long t; };$/;" s file: +D testsuite/libgomp.c/reduction-14.c /^struct D { long t; };$/;" s file: +D testsuite/libgomp.c/reduction-8.c /^struct D { long t; };$/;" s file: +D testsuite/libgomp.c/target-20.c /^int D[N];$/;" v +D testsuite/libgomp.fortran/lib2.f /^ DO/;" v +D testsuite/libgomp.fortran/lib3.f /^ DO/;" v +D testsuite/libgomp.fortran/strassen.f90 /^ double precision, save :: A(N,N), B(N,N), C(N,N), D(/;" v program:strassen_matmul +DELTA testsuite/libgomp.hsa.c/builtins-1.c 12;" d file: +DLSYM target.c 2364;" d file: +DLSYM target.c 2438;" d file: +DLSYM_FN plugin/plugin-hsa.c 491;" d file: +DLSYM_OPT target.c 2369;" d file: +DLSYM_OPT target.c 2439;" d file: +DOTDATA testsuite/libgomp.fortran/omp_orphan.f 13;" c program:ORPHAN +DOTDATA testsuite/libgomp.fortran/omp_orphan.f 32;" c subroutine:DOTPROD +DOTPROD testsuite/libgomp.fortran/omp_orphan.f /^ SUBROUTINE DOTPROD$/;" s +DO_PRAGMA testsuite/libgomp.c++/for-13.C 22;" d file: +DO_PRAGMA testsuite/libgomp.c++/for-14.C 23;" d file: +DO_PRAGMA testsuite/libgomp.c/for-5.c 24;" d file: +DO_PRAGMA testsuite/libgomp.c/for-6.c 25;" d file: +DO_PRAGMA testsuite/libgomp.oacc-c-c++-common/reduction-5.c 18;" d file: +DO_PRAGMA testsuite/libgomp.oacc-c-c++-common/reduction.h 4;" d +DoWorkVec testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c /^int DoWorkVec (int nw)$/;" f +E testsuite/libgomp.c++/udr-6.C /^struct E : A, B {};$/;" s file: +E testsuite/libgomp.c/doacross-1.c 93;" d file: +E testsuite/libgomp.c/doacross-2.c 95;" d file: +E testsuite/libgomp.c/doacross-3.c 95;" d file: +E testsuite/libgomp.c/loop-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +E testsuite/libgomp.c/ordered-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +E testsuite/libgomp.fortran/lib2.f /^ DOUBLE /;" v +E testsuite/libgomp.fortran/lib3.f /^ DOUBLE /;" v +EPS testsuite/libgomp.c++/examples-4/target_data-5.C 5;" d file: +EPS testsuite/libgomp.c/examples-4/async_target-1.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/async_target-2.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/declare_target-3.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/declare_target-4.c 6;" d file: +EPS testsuite/libgomp.c/examples-4/declare_target-5.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/simd-1.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/simd-2.c 6;" d file: +EPS testsuite/libgomp.c/examples-4/simd-3.c 6;" d file: +EPS testsuite/libgomp.c/examples-4/simd-4.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/simd-5.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/simd-6.c 6;" d file: +EPS testsuite/libgomp.c/examples-4/simd-8.c 8;" d file: +EPS testsuite/libgomp.c/examples-4/target-4.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/target-5.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/target_data-4.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/target_data-6.c 7;" d file: +EPS testsuite/libgomp.c/examples-4/task_dep-5.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/teams-2.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/teams-3.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/teams-4.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/teams-5.c 5;" d file: +EPS testsuite/libgomp.c/examples-4/teams-6.c 5;" d file: +EPS testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ double precision, parameter :: EPS /;" v program:SIMD3 +EPS testsuite/libgomp.fortran/examples-4/simd-8.f90 /^ real, parameter :: EPS /;" v program:simd_8f +Exception openacc_lib.h /^! permissions described in the GCC Runtime Library Exception, version$/;" v +F testsuite/libgomp.c++/for-10.C 13;" d file: +F testsuite/libgomp.c++/for-10.C 16;" d file: +F testsuite/libgomp.c++/for-10.C 19;" d file: +F testsuite/libgomp.c++/for-10.C 24;" d file: +F testsuite/libgomp.c++/for-10.C 27;" d file: +F testsuite/libgomp.c++/for-10.C 6;" d file: +F testsuite/libgomp.c++/for-11.C 15;" d file: +F testsuite/libgomp.c++/for-11.C 18;" d file: +F testsuite/libgomp.c++/for-11.C 25;" d file: +F testsuite/libgomp.c++/for-11.C 28;" d file: +F testsuite/libgomp.c++/for-11.C 35;" d file: +F testsuite/libgomp.c++/for-11.C 38;" d file: +F testsuite/libgomp.c++/for-11.C 45;" d file: +F testsuite/libgomp.c++/for-11.C 48;" d file: +F testsuite/libgomp.c++/for-11.C 51;" d file: +F testsuite/libgomp.c++/for-11.C 54;" d file: +F testsuite/libgomp.c++/for-11.C 57;" d file: +F testsuite/libgomp.c++/for-11.C 60;" d file: +F testsuite/libgomp.c++/for-11.C 63;" d file: +F testsuite/libgomp.c++/for-11.C 66;" d file: +F testsuite/libgomp.c++/for-11.C 69;" d file: +F testsuite/libgomp.c++/for-11.C 8;" d file: +F testsuite/libgomp.c++/for-12.C 15;" d file: +F testsuite/libgomp.c++/for-12.C 18;" d file: +F testsuite/libgomp.c++/for-12.C 25;" d file: +F testsuite/libgomp.c++/for-12.C 8;" d file: +F testsuite/libgomp.c++/for-13.C 100;" d file: +F testsuite/libgomp.c++/for-13.C 103;" d file: +F testsuite/libgomp.c++/for-13.C 106;" d file: +F testsuite/libgomp.c++/for-13.C 109;" d file: +F testsuite/libgomp.c++/for-13.C 15;" d file: +F testsuite/libgomp.c++/for-13.C 26;" d file: +F testsuite/libgomp.c++/for-13.C 29;" d file: +F testsuite/libgomp.c++/for-13.C 32;" d file: +F testsuite/libgomp.c++/for-13.C 39;" d file: +F testsuite/libgomp.c++/for-13.C 42;" d file: +F testsuite/libgomp.c++/for-13.C 45;" d file: +F testsuite/libgomp.c++/for-13.C 48;" d file: +F testsuite/libgomp.c++/for-13.C 55;" d file: +F testsuite/libgomp.c++/for-13.C 58;" d file: +F testsuite/libgomp.c++/for-13.C 65;" d file: +F testsuite/libgomp.c++/for-13.C 68;" d file: +F testsuite/libgomp.c++/for-13.C 75;" d file: +F testsuite/libgomp.c++/for-13.C 78;" d file: +F testsuite/libgomp.c++/for-13.C 85;" d file: +F testsuite/libgomp.c++/for-13.C 88;" d file: +F testsuite/libgomp.c++/for-13.C 8;" d file: +F testsuite/libgomp.c++/for-13.C 91;" d file: +F testsuite/libgomp.c++/for-13.C 94;" d file: +F testsuite/libgomp.c++/for-13.C 97;" d file: +F testsuite/libgomp.c++/for-14.C 15;" d file: +F testsuite/libgomp.c++/for-14.C 28;" d file: +F testsuite/libgomp.c++/for-14.C 35;" d file: +F testsuite/libgomp.c++/for-14.C 38;" d file: +F testsuite/libgomp.c++/for-14.C 45;" d file: +F testsuite/libgomp.c++/for-14.C 48;" d file: +F testsuite/libgomp.c++/for-14.C 55;" d file: +F testsuite/libgomp.c++/for-14.C 58;" d file: +F testsuite/libgomp.c++/for-14.C 65;" d file: +F testsuite/libgomp.c++/for-14.C 68;" d file: +F testsuite/libgomp.c++/for-14.C 71;" d file: +F testsuite/libgomp.c++/for-14.C 74;" d file: +F testsuite/libgomp.c++/for-14.C 77;" d file: +F testsuite/libgomp.c++/for-14.C 80;" d file: +F testsuite/libgomp.c++/for-14.C 83;" d file: +F testsuite/libgomp.c++/for-14.C 86;" d file: +F testsuite/libgomp.c++/for-14.C 89;" d file: +F testsuite/libgomp.c++/for-14.C 8;" d file: +F testsuite/libgomp.c++/for-9.C 12;" d file: +F testsuite/libgomp.c++/for-9.C 15;" d file: +F testsuite/libgomp.c++/for-9.C 6;" d file: +F testsuite/libgomp.c++/for-9.C 9;" d file: +F testsuite/libgomp.c++/udr-6.C /^struct F : C, D {};$/;" s file: +F testsuite/libgomp.c/examples-4/async_target-1.c /^float F (float a)$/;" f +F testsuite/libgomp.c/for-1.c 11;" d file: +F testsuite/libgomp.c/for-1.c 14;" d file: +F testsuite/libgomp.c/for-1.c 17;" d file: +F testsuite/libgomp.c/for-1.c 8;" d file: +F testsuite/libgomp.c/for-2.c 15;" d file: +F testsuite/libgomp.c/for-2.c 18;" d file: +F testsuite/libgomp.c/for-2.c 21;" d file: +F testsuite/libgomp.c/for-2.c 26;" d file: +F testsuite/libgomp.c/for-2.c 29;" d file: +F testsuite/libgomp.c/for-2.c 8;" d file: +F testsuite/libgomp.c/for-3.c 10;" d file: +F testsuite/libgomp.c/for-3.c 17;" d file: +F testsuite/libgomp.c/for-3.c 20;" d file: +F testsuite/libgomp.c/for-3.c 27;" d file: +F testsuite/libgomp.c/for-3.c 30;" d file: +F testsuite/libgomp.c/for-3.c 37;" d file: +F testsuite/libgomp.c/for-3.c 40;" d file: +F testsuite/libgomp.c/for-3.c 47;" d file: +F testsuite/libgomp.c/for-3.c 50;" d file: +F testsuite/libgomp.c/for-3.c 53;" d file: +F testsuite/libgomp.c/for-3.c 56;" d file: +F testsuite/libgomp.c/for-3.c 59;" d file: +F testsuite/libgomp.c/for-3.c 62;" d file: +F testsuite/libgomp.c/for-3.c 65;" d file: +F testsuite/libgomp.c/for-3.c 68;" d file: +F testsuite/libgomp.c/for-3.c 71;" d file: +F testsuite/libgomp.c/for-4.c 15;" d file: +F testsuite/libgomp.c/for-4.c 18;" d file: +F testsuite/libgomp.c/for-4.c 25;" d file: +F testsuite/libgomp.c/for-4.c 8;" d file: +F testsuite/libgomp.c/for-5.c 102;" d file: +F testsuite/libgomp.c/for-5.c 105;" d file: +F testsuite/libgomp.c/for-5.c 108;" d file: +F testsuite/libgomp.c/for-5.c 10;" d file: +F testsuite/libgomp.c/for-5.c 111;" d file: +F testsuite/libgomp.c/for-5.c 17;" d file: +F testsuite/libgomp.c/for-5.c 28;" d file: +F testsuite/libgomp.c/for-5.c 31;" d file: +F testsuite/libgomp.c/for-5.c 34;" d file: +F testsuite/libgomp.c/for-5.c 41;" d file: +F testsuite/libgomp.c/for-5.c 44;" d file: +F testsuite/libgomp.c/for-5.c 47;" d file: +F testsuite/libgomp.c/for-5.c 50;" d file: +F testsuite/libgomp.c/for-5.c 57;" d file: +F testsuite/libgomp.c/for-5.c 60;" d file: +F testsuite/libgomp.c/for-5.c 67;" d file: +F testsuite/libgomp.c/for-5.c 70;" d file: +F testsuite/libgomp.c/for-5.c 77;" d file: +F testsuite/libgomp.c/for-5.c 80;" d file: +F testsuite/libgomp.c/for-5.c 87;" d file: +F testsuite/libgomp.c/for-5.c 90;" d file: +F testsuite/libgomp.c/for-5.c 93;" d file: +F testsuite/libgomp.c/for-5.c 96;" d file: +F testsuite/libgomp.c/for-5.c 99;" d file: +F testsuite/libgomp.c/for-6.c 10;" d file: +F testsuite/libgomp.c/for-6.c 17;" d file: +F testsuite/libgomp.c/for-6.c 30;" d file: +F testsuite/libgomp.c/for-6.c 37;" d file: +F testsuite/libgomp.c/for-6.c 40;" d file: +F testsuite/libgomp.c/for-6.c 47;" d file: +F testsuite/libgomp.c/for-6.c 50;" d file: +F testsuite/libgomp.c/for-6.c 57;" d file: +F testsuite/libgomp.c/for-6.c 60;" d file: +F testsuite/libgomp.c/for-6.c 67;" d file: +F testsuite/libgomp.c/for-6.c 70;" d file: +F testsuite/libgomp.c/for-6.c 73;" d file: +F testsuite/libgomp.c/for-6.c 76;" d file: +F testsuite/libgomp.c/for-6.c 79;" d file: +F testsuite/libgomp.c/for-6.c 82;" d file: +F testsuite/libgomp.c/for-6.c 85;" d file: +F testsuite/libgomp.c/for-6.c 88;" d file: +F testsuite/libgomp.c/for-6.c 91;" d file: +F testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^real function F /;" f +F03_2_7_1d testsuite/libgomp.fortran/task3.f90 /^program F03_2_7_1d$/;" p +F1 testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ SUBROUTINE F1(/;" s +F2 testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ SUBROUTINE F2(/;" s +FIRSTIN testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ LOGICAL :: FIRSTIN /;" v program:A22_7_GOOD +FLAG_COPY oacc-mem.c 424;" d file: +FLAG_COPYOUT oacc-mem.c 523;" d file: +FLAG_CREATE oacc-mem.c 423;" d file: +FLAG_PRESENT oacc-mem.c 422;" d file: +FN1 testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ REAL FUNCTION FN1(/;" f +FN2 testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ REAL FUNCTION FN2(/;" f +FRAC testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c 7;" d file: +FRAC testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c 7;" d file: +FRAC testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c 3;" d file: +FRAC testsuite/libgomp.oacc-c-c++-common/reduction-flt.c 3;" d file: +FUTEX_PRIVATE_FLAG config/linux/wait.h 38;" d +FUTEX_WAIT config/linux/mips/futex.h 34;" d +FUTEX_WAIT config/linux/wait.h 36;" d +FUTEX_WAKE config/linux/mips/futex.h 35;" d +FUTEX_WAKE config/linux/wait.h 37;" d +Foo testsuite/libgomp.oacc-c-c++-common/acc-on-device.c /^int Foo (acc_device_t x)$/;" f +Foundation openacc_lib.h /^! Copyright (C) 2014-2017 Free Software Foundation, Inc.$/;" v +Foundation openacc_lib.h /^! the Free Software Foundation; either version 3, or (at your option)$/;" v +G testsuite/libgomp.c++/for-10.C 14;" d file: +G testsuite/libgomp.c++/for-10.C 17;" d file: +G testsuite/libgomp.c++/for-10.C 20;" d file: +G testsuite/libgomp.c++/for-10.C 25;" d file: +G testsuite/libgomp.c++/for-10.C 28;" d file: +G testsuite/libgomp.c++/for-10.C 7;" d file: +G testsuite/libgomp.c++/for-11.C 16;" d file: +G testsuite/libgomp.c++/for-11.C 19;" d file: +G testsuite/libgomp.c++/for-11.C 26;" d file: +G testsuite/libgomp.c++/for-11.C 29;" d file: +G testsuite/libgomp.c++/for-11.C 36;" d file: +G testsuite/libgomp.c++/for-11.C 39;" d file: +G testsuite/libgomp.c++/for-11.C 46;" d file: +G testsuite/libgomp.c++/for-11.C 49;" d file: +G testsuite/libgomp.c++/for-11.C 52;" d file: +G testsuite/libgomp.c++/for-11.C 55;" d file: +G testsuite/libgomp.c++/for-11.C 58;" d file: +G testsuite/libgomp.c++/for-11.C 61;" d file: +G testsuite/libgomp.c++/for-11.C 64;" d file: +G testsuite/libgomp.c++/for-11.C 67;" d file: +G testsuite/libgomp.c++/for-11.C 70;" d file: +G testsuite/libgomp.c++/for-11.C 9;" d file: +G testsuite/libgomp.c++/for-12.C 16;" d file: +G testsuite/libgomp.c++/for-12.C 19;" d file: +G testsuite/libgomp.c++/for-12.C 26;" d file: +G testsuite/libgomp.c++/for-12.C 9;" d file: +G testsuite/libgomp.c++/for-13.C 101;" d file: +G testsuite/libgomp.c++/for-13.C 104;" d file: +G testsuite/libgomp.c++/for-13.C 107;" d file: +G testsuite/libgomp.c++/for-13.C 110;" d file: +G testsuite/libgomp.c++/for-13.C 16;" d file: +G testsuite/libgomp.c++/for-13.C 27;" d file: +G testsuite/libgomp.c++/for-13.C 30;" d file: +G testsuite/libgomp.c++/for-13.C 33;" d file: +G testsuite/libgomp.c++/for-13.C 40;" d file: +G testsuite/libgomp.c++/for-13.C 43;" d file: +G testsuite/libgomp.c++/for-13.C 46;" d file: +G testsuite/libgomp.c++/for-13.C 49;" d file: +G testsuite/libgomp.c++/for-13.C 56;" d file: +G testsuite/libgomp.c++/for-13.C 59;" d file: +G testsuite/libgomp.c++/for-13.C 66;" d file: +G testsuite/libgomp.c++/for-13.C 69;" d file: +G testsuite/libgomp.c++/for-13.C 76;" d file: +G testsuite/libgomp.c++/for-13.C 79;" d file: +G testsuite/libgomp.c++/for-13.C 86;" d file: +G testsuite/libgomp.c++/for-13.C 89;" d file: +G testsuite/libgomp.c++/for-13.C 92;" d file: +G testsuite/libgomp.c++/for-13.C 95;" d file: +G testsuite/libgomp.c++/for-13.C 98;" d file: +G testsuite/libgomp.c++/for-13.C 9;" d file: +G testsuite/libgomp.c++/for-14.C 16;" d file: +G testsuite/libgomp.c++/for-14.C 29;" d file: +G testsuite/libgomp.c++/for-14.C 36;" d file: +G testsuite/libgomp.c++/for-14.C 39;" d file: +G testsuite/libgomp.c++/for-14.C 46;" d file: +G testsuite/libgomp.c++/for-14.C 49;" d file: +G testsuite/libgomp.c++/for-14.C 56;" d file: +G testsuite/libgomp.c++/for-14.C 59;" d file: +G testsuite/libgomp.c++/for-14.C 66;" d file: +G testsuite/libgomp.c++/for-14.C 69;" d file: +G testsuite/libgomp.c++/for-14.C 72;" d file: +G testsuite/libgomp.c++/for-14.C 75;" d file: +G testsuite/libgomp.c++/for-14.C 78;" d file: +G testsuite/libgomp.c++/for-14.C 81;" d file: +G testsuite/libgomp.c++/for-14.C 84;" d file: +G testsuite/libgomp.c++/for-14.C 87;" d file: +G testsuite/libgomp.c++/for-14.C 90;" d file: +G testsuite/libgomp.c++/for-14.C 9;" d file: +G testsuite/libgomp.c++/for-9.C 10;" d file: +G testsuite/libgomp.c++/for-9.C 13;" d file: +G testsuite/libgomp.c++/for-9.C 16;" d file: +G testsuite/libgomp.c++/for-9.C 7;" d file: +G testsuite/libgomp.c++/udr-6.C /^struct G : E, F {};$/;" s file: +G testsuite/libgomp.c/for-1.c 12;" d file: +G testsuite/libgomp.c/for-1.c 15;" d file: +G testsuite/libgomp.c/for-1.c 18;" d file: +G testsuite/libgomp.c/for-1.c 9;" d file: +G testsuite/libgomp.c/for-2.c 16;" d file: +G testsuite/libgomp.c/for-2.c 19;" d file: +G testsuite/libgomp.c/for-2.c 22;" d file: +G testsuite/libgomp.c/for-2.c 27;" d file: +G testsuite/libgomp.c/for-2.c 30;" d file: +G testsuite/libgomp.c/for-2.c 9;" d file: +G testsuite/libgomp.c/for-3.c 11;" d file: +G testsuite/libgomp.c/for-3.c 18;" d file: +G testsuite/libgomp.c/for-3.c 21;" d file: +G testsuite/libgomp.c/for-3.c 28;" d file: +G testsuite/libgomp.c/for-3.c 31;" d file: +G testsuite/libgomp.c/for-3.c 38;" d file: +G testsuite/libgomp.c/for-3.c 41;" d file: +G testsuite/libgomp.c/for-3.c 48;" d file: +G testsuite/libgomp.c/for-3.c 51;" d file: +G testsuite/libgomp.c/for-3.c 54;" d file: +G testsuite/libgomp.c/for-3.c 57;" d file: +G testsuite/libgomp.c/for-3.c 60;" d file: +G testsuite/libgomp.c/for-3.c 63;" d file: +G testsuite/libgomp.c/for-3.c 66;" d file: +G testsuite/libgomp.c/for-3.c 69;" d file: +G testsuite/libgomp.c/for-3.c 72;" d file: +G testsuite/libgomp.c/for-4.c 16;" d file: +G testsuite/libgomp.c/for-4.c 19;" d file: +G testsuite/libgomp.c/for-4.c 26;" d file: +G testsuite/libgomp.c/for-4.c 9;" d file: +G testsuite/libgomp.c/for-5.c 100;" d file: +G testsuite/libgomp.c/for-5.c 103;" d file: +G testsuite/libgomp.c/for-5.c 106;" d file: +G testsuite/libgomp.c/for-5.c 109;" d file: +G testsuite/libgomp.c/for-5.c 112;" d file: +G testsuite/libgomp.c/for-5.c 11;" d file: +G testsuite/libgomp.c/for-5.c 18;" d file: +G testsuite/libgomp.c/for-5.c 29;" d file: +G testsuite/libgomp.c/for-5.c 32;" d file: +G testsuite/libgomp.c/for-5.c 35;" d file: +G testsuite/libgomp.c/for-5.c 42;" d file: +G testsuite/libgomp.c/for-5.c 45;" d file: +G testsuite/libgomp.c/for-5.c 48;" d file: +G testsuite/libgomp.c/for-5.c 51;" d file: +G testsuite/libgomp.c/for-5.c 58;" d file: +G testsuite/libgomp.c/for-5.c 61;" d file: +G testsuite/libgomp.c/for-5.c 68;" d file: +G testsuite/libgomp.c/for-5.c 71;" d file: +G testsuite/libgomp.c/for-5.c 78;" d file: +G testsuite/libgomp.c/for-5.c 81;" d file: +G testsuite/libgomp.c/for-5.c 88;" d file: +G testsuite/libgomp.c/for-5.c 91;" d file: +G testsuite/libgomp.c/for-5.c 94;" d file: +G testsuite/libgomp.c/for-5.c 97;" d file: +G testsuite/libgomp.c/for-6.c 11;" d file: +G testsuite/libgomp.c/for-6.c 18;" d file: +G testsuite/libgomp.c/for-6.c 31;" d file: +G testsuite/libgomp.c/for-6.c 38;" d file: +G testsuite/libgomp.c/for-6.c 41;" d file: +G testsuite/libgomp.c/for-6.c 48;" d file: +G testsuite/libgomp.c/for-6.c 51;" d file: +G testsuite/libgomp.c/for-6.c 58;" d file: +G testsuite/libgomp.c/for-6.c 61;" d file: +G testsuite/libgomp.c/for-6.c 68;" d file: +G testsuite/libgomp.c/for-6.c 71;" d file: +G testsuite/libgomp.c/for-6.c 74;" d file: +G testsuite/libgomp.c/for-6.c 77;" d file: +G testsuite/libgomp.c/for-6.c 80;" d file: +G testsuite/libgomp.c/for-6.c 83;" d file: +G testsuite/libgomp.c/for-6.c 86;" d file: +G testsuite/libgomp.c/for-6.c 89;" d file: +G testsuite/libgomp.c/for-6.c 92;" d file: +G testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ INTEGE/;" v program:A19 +G testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ INTEGE/;" f +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c 15;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c 31;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c 36;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c 53;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-2.c 14;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-2.c 32;" d file: +GANGS testsuite/libgomp.oacc-c-c++-common/par-reduction-2.c 37;" d file: +GANG_ID testsuite/libgomp.oacc-c-c++-common/gang-static-2.c 11;" d file: +GCC_CUDA_H plugin/cuda/cuda.h 30;" d +GFS_AUTO libgomp.h /^ GFS_AUTO$/;" e enum:gomp_schedule_type +GFS_DYNAMIC libgomp.h /^ GFS_DYNAMIC,$/;" e enum:gomp_schedule_type +GFS_GUIDED libgomp.h /^ GFS_GUIDED,$/;" e enum:gomp_schedule_type +GFS_RUNTIME libgomp.h /^ GFS_RUNTIME,$/;" e enum:gomp_schedule_type +GFS_STATIC libgomp.h /^ GFS_STATIC,$/;" e enum:gomp_schedule_type +GOACC_data_end oacc-parallel.c /^GOACC_data_end (void)$/;" f +GOACC_data_start oacc-parallel.c /^GOACC_data_start (int device, size_t mapnum,$/;" f +GOACC_declare oacc-parallel.c /^GOACC_declare (int device, size_t mapnum,$/;" f +GOACC_enter_exit_data oacc-parallel.c /^GOACC_enter_exit_data (int device, size_t mapnum,$/;" f +GOACC_get_num_threads oacc-parallel.c /^GOACC_get_num_threads (void)$/;" f +GOACC_get_thread_num oacc-parallel.c /^GOACC_get_thread_num (void)$/;" f +GOACC_parallel oacc-parallel.c /^GOACC_parallel (int device, void (*fn) (void *),$/;" f +GOACC_parallel_keyed oacc-parallel.c /^GOACC_parallel_keyed (int device, void (*fn) (void *),$/;" f +GOACC_update oacc-parallel.c /^GOACC_update (int device, size_t mapnum,$/;" f +GOACC_wait oacc-parallel.c /^GOACC_wait (int async, int num_waits, ...)$/;" f +GOMP_BARRIER_H config/linux/bar.h 31;" d +GOMP_BARRIER_H config/nvptx/bar.h 31;" d +GOMP_BARRIER_H config/posix/bar.h 32;" d +GOMP_BARRIER_H config/rtems/bar.h 31;" d +GOMP_CANCEL_DO libgomp.h /^ GOMP_CANCEL_DO = GOMP_CANCEL_LOOP,$/;" e enum:gomp_cancel_kind +GOMP_CANCEL_FOR libgomp.h /^ GOMP_CANCEL_FOR = GOMP_CANCEL_LOOP,$/;" e enum:gomp_cancel_kind +GOMP_CANCEL_LOOP libgomp.h /^ GOMP_CANCEL_LOOP = 2,$/;" e enum:gomp_cancel_kind +GOMP_CANCEL_PARALLEL libgomp.h /^ GOMP_CANCEL_PARALLEL = 1,$/;" e enum:gomp_cancel_kind +GOMP_CANCEL_SECTIONS libgomp.h /^ GOMP_CANCEL_SECTIONS = 4,$/;" e enum:gomp_cancel_kind +GOMP_CANCEL_TASKGROUP libgomp.h /^ GOMP_CANCEL_TASKGROUP = 8$/;" e enum:gomp_cancel_kind +GOMP_DEFAULT_STACKSIZE config/darwin/thread-stacksize.h 29;" d +GOMP_DEFAULT_STACKSIZE config/nvptx/thread-stacksize.h 27;" d +GOMP_DEFAULT_STACKSIZE config/posix/thread-stacksize.h 27;" d +GOMP_DEVICE_FINALIZED libgomp.h /^ GOMP_DEVICE_FINALIZED$/;" e enum:gomp_device_state +GOMP_DEVICE_INITIALIZED libgomp.h /^ GOMP_DEVICE_INITIALIZED,$/;" e enum:gomp_device_state +GOMP_DEVICE_UNINITIALIZED libgomp.h /^ GOMP_DEVICE_UNINITIALIZED,$/;" e enum:gomp_device_state +GOMP_DOACROSS_H config/linux/doacross.h 29;" d +GOMP_DOACROSS_H config/nvptx/doacross.h 29;" d +GOMP_DOACROSS_H config/posix/doacross.h 29;" d +GOMP_DYNAMIC_TDG tdg.h /^ GOMP_DYNAMIC_TDG = 1,$/;" e enum:GOMP_dep_check +GOMP_MAP_VARS_DATA libgomp.h /^ GOMP_MAP_VARS_DATA,$/;" e enum:gomp_map_vars_kind +GOMP_MAP_VARS_ENTER_DATA libgomp.h /^ GOMP_MAP_VARS_ENTER_DATA$/;" e enum:gomp_map_vars_kind +GOMP_MAP_VARS_OPENACC libgomp.h /^ GOMP_MAP_VARS_OPENACC,$/;" e enum:gomp_map_vars_kind +GOMP_MAP_VARS_TARGET libgomp.h /^ GOMP_MAP_VARS_TARGET,$/;" e enum:gomp_map_vars_kind +GOMP_MUTEX_H config/linux/mutex.h 31;" d +GOMP_MUTEX_H config/nvptx/mutex.h 31;" d +GOMP_MUTEX_H config/posix/mutex.h 30;" d +GOMP_MUTEX_H config/rtems/mutex.h 29;" d +GOMP_MUTEX_INIT_0 config/linux/mutex.h 35;" d +GOMP_MUTEX_INIT_0 config/nvptx/mutex.h 35;" d +GOMP_MUTEX_INIT_0 config/posix/mutex.h 36;" d +GOMP_MUTEX_INIT_0 config/rtems/mutex.h 35;" d +GOMP_OFFLOAD_CAP_NATIVE_EXEC libgomp-plugin.h 42;" d +GOMP_OFFLOAD_CAP_OPENACC_200 libgomp-plugin.h 44;" d +GOMP_OFFLOAD_CAP_OPENMP_400 libgomp-plugin.h 43;" d +GOMP_OFFLOAD_CAP_SHARED_MEM libgomp-plugin.h 41;" d +GOMP_OFFLOAD_alloc plugin/plugin-hsa.c /^GOMP_OFFLOAD_alloc (int ord, size_t size)$/;" f +GOMP_OFFLOAD_alloc plugin/plugin-nvptx.c /^GOMP_OFFLOAD_alloc (int ord, size_t size)$/;" f +GOMP_OFFLOAD_async_run plugin/plugin-hsa.c /^GOMP_OFFLOAD_async_run (int device, void *tgt_fn, void *tgt_vars,$/;" f +GOMP_OFFLOAD_async_run plugin/plugin-nvptx.c /^GOMP_OFFLOAD_async_run (int ord, void *tgt_fn, void *tgt_vars, void **args,$/;" f +GOMP_OFFLOAD_can_run plugin/plugin-hsa.c /^GOMP_OFFLOAD_can_run (void *fn_ptr)$/;" f +GOMP_OFFLOAD_dev2dev plugin/plugin-hsa.c /^GOMP_OFFLOAD_dev2dev (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_dev2dev plugin/plugin-nvptx.c /^GOMP_OFFLOAD_dev2dev (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_dev2host plugin/plugin-hsa.c /^GOMP_OFFLOAD_dev2host (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_dev2host plugin/plugin-nvptx.c /^GOMP_OFFLOAD_dev2host (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_fini_device plugin/plugin-hsa.c /^GOMP_OFFLOAD_fini_device (int n)$/;" f +GOMP_OFFLOAD_fini_device plugin/plugin-nvptx.c /^GOMP_OFFLOAD_fini_device (int n)$/;" f +GOMP_OFFLOAD_free plugin/plugin-hsa.c /^GOMP_OFFLOAD_free (int ord, void *ptr)$/;" f +GOMP_OFFLOAD_free plugin/plugin-nvptx.c /^GOMP_OFFLOAD_free (int ord, void *ptr)$/;" f +GOMP_OFFLOAD_get_caps plugin/plugin-hsa.c /^GOMP_OFFLOAD_get_caps (void)$/;" f +GOMP_OFFLOAD_get_caps plugin/plugin-nvptx.c /^GOMP_OFFLOAD_get_caps (void)$/;" f +GOMP_OFFLOAD_get_name plugin/plugin-hsa.c /^GOMP_OFFLOAD_get_name (void)$/;" f +GOMP_OFFLOAD_get_name plugin/plugin-nvptx.c /^GOMP_OFFLOAD_get_name (void)$/;" f +GOMP_OFFLOAD_get_num_devices plugin/plugin-hsa.c /^GOMP_OFFLOAD_get_num_devices (void)$/;" f +GOMP_OFFLOAD_get_num_devices plugin/plugin-nvptx.c /^GOMP_OFFLOAD_get_num_devices (void)$/;" f +GOMP_OFFLOAD_get_type plugin/plugin-hsa.c /^GOMP_OFFLOAD_get_type (void)$/;" f +GOMP_OFFLOAD_get_type plugin/plugin-nvptx.c /^GOMP_OFFLOAD_get_type (void)$/;" f +GOMP_OFFLOAD_host2dev plugin/plugin-hsa.c /^GOMP_OFFLOAD_host2dev (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_host2dev plugin/plugin-nvptx.c /^GOMP_OFFLOAD_host2dev (int ord, void *dst, const void *src, size_t n)$/;" f +GOMP_OFFLOAD_init_device plugin/plugin-hsa.c /^GOMP_OFFLOAD_init_device (int n)$/;" f +GOMP_OFFLOAD_init_device plugin/plugin-nvptx.c /^GOMP_OFFLOAD_init_device (int n)$/;" f +GOMP_OFFLOAD_load_image plugin/plugin-hsa.c /^GOMP_OFFLOAD_load_image (int ord, unsigned version, const void *target_data,$/;" f +GOMP_OFFLOAD_load_image plugin/plugin-nvptx.c /^GOMP_OFFLOAD_load_image (int ord, unsigned version, const void *target_data,$/;" f +GOMP_OFFLOAD_openacc_async_set_async plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_set_async (int async)$/;" f +GOMP_OFFLOAD_openacc_async_test plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_test (int async)$/;" f +GOMP_OFFLOAD_openacc_async_test_all plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_test_all (void)$/;" f +GOMP_OFFLOAD_openacc_async_wait plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_wait (int async)$/;" f +GOMP_OFFLOAD_openacc_async_wait_all plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_wait_all (void)$/;" f +GOMP_OFFLOAD_openacc_async_wait_all_async plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_wait_all_async (int async)$/;" f +GOMP_OFFLOAD_openacc_async_wait_async plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_async_wait_async (int async1, int async2)$/;" f +GOMP_OFFLOAD_openacc_create_thread_data plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_create_thread_data (int ord)$/;" f +GOMP_OFFLOAD_openacc_cuda_get_current_context plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_cuda_get_current_context (void)$/;" f +GOMP_OFFLOAD_openacc_cuda_get_current_device plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_cuda_get_current_device (void)$/;" f +GOMP_OFFLOAD_openacc_cuda_get_stream plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_cuda_get_stream (int async)$/;" f +GOMP_OFFLOAD_openacc_cuda_set_stream plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_cuda_set_stream (int async, void *stream)$/;" f +GOMP_OFFLOAD_openacc_destroy_thread_data plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_destroy_thread_data (void *data)$/;" f +GOMP_OFFLOAD_openacc_exec plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_exec (void (*fn) (void *), size_t mapnum,$/;" f +GOMP_OFFLOAD_openacc_register_async_cleanup plugin/plugin-nvptx.c /^GOMP_OFFLOAD_openacc_register_async_cleanup (void *targ_mem_desc, int async)$/;" f +GOMP_OFFLOAD_run plugin/plugin-hsa.c /^GOMP_OFFLOAD_run (int n __attribute__((unused)),$/;" f +GOMP_OFFLOAD_run plugin/plugin-nvptx.c /^GOMP_OFFLOAD_run (int ord, void *tgt_fn, void *tgt_vars, void **args)$/;" f +GOMP_OFFLOAD_unload_image plugin/plugin-hsa.c /^GOMP_OFFLOAD_unload_image (int n, unsigned version, const void *target_data)$/;" f +GOMP_OFFLOAD_unload_image plugin/plugin-nvptx.c /^GOMP_OFFLOAD_unload_image (int ord, unsigned version, const void *target_data)$/;" f +GOMP_OFFLOAD_version plugin/plugin-hsa.c /^GOMP_OFFLOAD_version (void)$/;" f +GOMP_OFFLOAD_version plugin/plugin-nvptx.c /^GOMP_OFFLOAD_version (void)$/;" f +GOMP_PLUGIN_acc_thread oacc-plugin.c /^GOMP_PLUGIN_acc_thread (void)$/;" f +GOMP_PLUGIN_async_unmap_vars oacc-plugin.c /^GOMP_PLUGIN_async_unmap_vars (void *ptr, int async)$/;" f +GOMP_PLUGIN_debug libgomp-plugin.c /^GOMP_PLUGIN_debug (int kind, const char *msg, ...)$/;" f +GOMP_PLUGIN_error libgomp-plugin.c /^GOMP_PLUGIN_error (const char *msg, ...)$/;" f +GOMP_PLUGIN_fatal libgomp-plugin.c /^GOMP_PLUGIN_fatal (const char *msg, ...)$/;" f +GOMP_PLUGIN_malloc libgomp-plugin.c /^GOMP_PLUGIN_malloc (size_t size)$/;" f +GOMP_PLUGIN_malloc_cleared libgomp-plugin.c /^GOMP_PLUGIN_malloc_cleared (size_t size)$/;" f +GOMP_PLUGIN_realloc libgomp-plugin.c /^GOMP_PLUGIN_realloc (void *ptr, size_t size)$/;" f +GOMP_PLUGIN_target_task_completion task.c /^GOMP_PLUGIN_target_task_completion (void *data)$/;" f +GOMP_POOL_H config/nvptx/pool.h 30;" d +GOMP_POOL_H config/posix/pool.h 30;" d +GOMP_POOL_H config/rtems/pool.h 30;" d +GOMP_PROC_H config/linux/proc.h 27;" d +GOMP_PTRLOCK_H config/linux/ptrlock.h 38;" d +GOMP_PTRLOCK_H config/nvptx/ptrlock.h 38;" d +GOMP_PTRLOCK_H config/posix/ptrlock.h 30;" d +GOMP_SEM_H config/linux/sem.h 34;" d +GOMP_SEM_H config/nvptx/sem.h 31;" d +GOMP_SEM_H config/posix/sem.h 35;" d +GOMP_SEM_H config/rtems/sem.h 29;" d +GOMP_SIMPLE_BARRIER_H config/nvptx/simple-bar.h 32;" d +GOMP_SIMPLE_BARRIER_H config/posix/simple-bar.h 30;" d +GOMP_STATIC_TDG tdg.h /^ GOMP_STATIC_TDG = 2$/;" e enum:GOMP_dep_check +GOMP_TARGET_TASK_BEFORE_MAP libgomp.h /^ GOMP_TARGET_TASK_BEFORE_MAP,$/;" e enum:gomp_target_task_state +GOMP_TARGET_TASK_DATA libgomp.h /^ GOMP_TARGET_TASK_DATA,$/;" e enum:gomp_target_task_state +GOMP_TARGET_TASK_FALLBACK libgomp.h /^ GOMP_TARGET_TASK_FALLBACK,$/;" e enum:gomp_target_task_state +GOMP_TARGET_TASK_FINISHED libgomp.h /^ GOMP_TARGET_TASK_FINISHED$/;" e enum:gomp_target_task_state +GOMP_TARGET_TASK_READY_TO_RUN libgomp.h /^ GOMP_TARGET_TASK_READY_TO_RUN,$/;" e enum:gomp_target_task_state +GOMP_TARGET_TASK_RUNNING libgomp.h /^ GOMP_TARGET_TASK_RUNNING,$/;" e enum:gomp_target_task_state +GOMP_TASK_ASYNC_RUNNING libgomp.h /^ GOMP_TASK_ASYNC_RUNNING$/;" e enum:gomp_task_kind +GOMP_TASK_IMPLICIT libgomp.h /^ GOMP_TASK_IMPLICIT,$/;" e enum:gomp_task_kind +GOMP_TASK_TIED libgomp.h /^ GOMP_TASK_TIED,$/;" e enum:gomp_task_kind +GOMP_TASK_UNDEFERRED libgomp.h /^ GOMP_TASK_UNDEFERRED,$/;" e enum:gomp_task_kind +GOMP_TASK_WAITING libgomp.h /^ GOMP_TASK_WAITING,$/;" e enum:gomp_task_kind +GOMP_WAIT_H config/linux/wait.h 31;" d +GOMP_atomic_end atomic.c /^GOMP_atomic_end (void)$/;" f +GOMP_atomic_start atomic.c /^GOMP_atomic_start (void)$/;" f +GOMP_barrier barrier.c /^GOMP_barrier (void)$/;" f +GOMP_barrier_cancel barrier.c /^GOMP_barrier_cancel (void)$/;" f +GOMP_cancellation_point parallel.c /^GOMP_cancellation_point (int which)$/;" f +GOMP_critical_end critical.c /^GOMP_critical_end (void)$/;" f +GOMP_critical_name_end critical.c /^GOMP_critical_name_end (void **pptr)$/;" f +GOMP_critical_name_start critical.c /^GOMP_critical_name_start (void **pptr)$/;" f +GOMP_critical_start critical.c /^GOMP_critical_start (void)$/;" f +GOMP_dep_check tdg.h /^enum GOMP_dep_check$/;" g +GOMP_doacross_post ordered.c /^GOMP_doacross_post (long *counts)$/;" f +GOMP_doacross_ull_post ordered.c /^GOMP_doacross_ull_post (gomp_ull *counts)$/;" f +GOMP_doacross_ull_wait ordered.c /^GOMP_doacross_ull_wait (gomp_ull first, ...)$/;" f +GOMP_doacross_wait ordered.c /^GOMP_doacross_wait (long first, ...)$/;" f +GOMP_exec_tdg tdg.c /^void GOMP_exec_tdg (void (*fn)(void *), void *data)$/;" f +GOMP_fill_task_data tdg.c /^void GOMP_fill_task_data(unsigned instance_id, void (*fn) (void *), void *data,$/;" f +GOMP_hsa_kernel_dispatch plugin/plugin-hsa.c /^struct GOMP_hsa_kernel_dispatch$/;" s file: +GOMP_init_tdg tdg.c /^void GOMP_init_tdg(unsigned int num_tdgs, struct gomp_tdg_node **tdg, unsigned short **tdg_ins,$/;" f +GOMP_kernel_launch_attributes plugin/plugin-hsa.c /^struct GOMP_kernel_launch_attributes$/;" s file: +GOMP_loop_doacross_dynamic_start loop.c /^GOMP_loop_doacross_dynamic_start (unsigned ncounts, long *counts,$/;" f +GOMP_loop_doacross_guided_start loop.c /^GOMP_loop_doacross_guided_start (unsigned ncounts, long *counts,$/;" f +GOMP_loop_doacross_runtime_start loop.c /^GOMP_loop_doacross_runtime_start (unsigned ncounts, long *counts,$/;" f +GOMP_loop_doacross_static_start loop.c /^GOMP_loop_doacross_static_start (unsigned ncounts, long *counts,$/;" f +GOMP_loop_dynamic_next loop.c /^GOMP_loop_dynamic_next (long *istart, long *iend)$/;" f +GOMP_loop_dynamic_start loop.c /^GOMP_loop_dynamic_start (long start, long end, long incr, long chunk_size,$/;" f +GOMP_loop_end loop.c /^GOMP_loop_end (void)$/;" f +GOMP_loop_end_cancel loop.c /^GOMP_loop_end_cancel (void)$/;" f +GOMP_loop_end_nowait loop.c /^GOMP_loop_end_nowait (void)$/;" f +GOMP_loop_guided_next loop.c /^GOMP_loop_guided_next (long *istart, long *iend)$/;" f +GOMP_loop_guided_start loop.c /^GOMP_loop_guided_start (long start, long end, long incr, long chunk_size,$/;" f +GOMP_loop_nonmonotonic_dynamic_next loop.c /^GOMP_loop_nonmonotonic_dynamic_next (long *istart, long *iend)$/;" f +GOMP_loop_nonmonotonic_dynamic_start loop.c /^GOMP_loop_nonmonotonic_dynamic_start (long start, long end, long incr,$/;" f +GOMP_loop_nonmonotonic_guided_next loop.c /^GOMP_loop_nonmonotonic_guided_next (long *istart, long *iend)$/;" f +GOMP_loop_nonmonotonic_guided_start loop.c /^GOMP_loop_nonmonotonic_guided_start (long start, long end, long incr,$/;" f +GOMP_loop_ordered_dynamic_next loop.c /^GOMP_loop_ordered_dynamic_next (long *istart, long *iend)$/;" f +GOMP_loop_ordered_dynamic_start loop.c /^GOMP_loop_ordered_dynamic_start (long start, long end, long incr,$/;" f +GOMP_loop_ordered_guided_next loop.c /^GOMP_loop_ordered_guided_next (long *istart, long *iend)$/;" f +GOMP_loop_ordered_guided_start loop.c /^GOMP_loop_ordered_guided_start (long start, long end, long incr,$/;" f +GOMP_loop_ordered_runtime_next loop.c /^GOMP_loop_ordered_runtime_next (long *istart, long *iend)$/;" f +GOMP_loop_ordered_runtime_start loop.c /^GOMP_loop_ordered_runtime_start (long start, long end, long incr,$/;" f +GOMP_loop_ordered_static_next loop.c /^GOMP_loop_ordered_static_next (long *istart, long *iend)$/;" f +GOMP_loop_ordered_static_start loop.c /^GOMP_loop_ordered_static_start (long start, long end, long incr,$/;" f +GOMP_loop_runtime_next loop.c /^GOMP_loop_runtime_next (long *istart, long *iend)$/;" f +GOMP_loop_runtime_start loop.c /^GOMP_loop_runtime_start (long start, long end, long incr,$/;" f +GOMP_loop_static_next loop.c /^GOMP_loop_static_next (long *istart, long *iend)$/;" f +GOMP_loop_static_start loop.c /^GOMP_loop_static_start (long start, long end, long incr, long chunk_size,$/;" f +GOMP_loop_ull_doacross_dynamic_start loop_ull.c /^GOMP_loop_ull_doacross_dynamic_start (unsigned ncounts, gomp_ull *counts,$/;" f +GOMP_loop_ull_doacross_guided_start loop_ull.c /^GOMP_loop_ull_doacross_guided_start (unsigned ncounts, gomp_ull *counts,$/;" f +GOMP_loop_ull_doacross_runtime_start loop_ull.c /^GOMP_loop_ull_doacross_runtime_start (unsigned ncounts, gomp_ull *counts,$/;" f +GOMP_loop_ull_doacross_static_start loop_ull.c /^GOMP_loop_ull_doacross_static_start (unsigned ncounts, gomp_ull *counts,$/;" f +GOMP_loop_ull_dynamic_next loop_ull.c /^GOMP_loop_ull_dynamic_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_dynamic_start loop_ull.c /^GOMP_loop_ull_dynamic_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_guided_next loop_ull.c /^GOMP_loop_ull_guided_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_guided_start loop_ull.c /^GOMP_loop_ull_guided_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_nonmonotonic_dynamic_next loop_ull.c /^GOMP_loop_ull_nonmonotonic_dynamic_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_nonmonotonic_dynamic_start loop_ull.c /^GOMP_loop_ull_nonmonotonic_dynamic_start (bool up, gomp_ull start,$/;" f +GOMP_loop_ull_nonmonotonic_guided_next loop_ull.c /^GOMP_loop_ull_nonmonotonic_guided_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_nonmonotonic_guided_start loop_ull.c /^GOMP_loop_ull_nonmonotonic_guided_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_ordered_dynamic_next loop_ull.c /^GOMP_loop_ull_ordered_dynamic_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_ordered_dynamic_start loop_ull.c /^GOMP_loop_ull_ordered_dynamic_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_ordered_guided_next loop_ull.c /^GOMP_loop_ull_ordered_guided_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_ordered_guided_start loop_ull.c /^GOMP_loop_ull_ordered_guided_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_ordered_runtime_next loop_ull.c /^GOMP_loop_ull_ordered_runtime_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_ordered_runtime_start loop_ull.c /^GOMP_loop_ull_ordered_runtime_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_ordered_static_next loop_ull.c /^GOMP_loop_ull_ordered_static_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_ordered_static_start loop_ull.c /^GOMP_loop_ull_ordered_static_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_runtime_next loop_ull.c /^GOMP_loop_ull_runtime_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_runtime_start loop_ull.c /^GOMP_loop_ull_runtime_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_loop_ull_static_next loop_ull.c /^GOMP_loop_ull_static_next (gomp_ull *istart, gomp_ull *iend)$/;" f +GOMP_loop_ull_static_start loop_ull.c /^GOMP_loop_ull_static_start (bool up, gomp_ull start, gomp_ull end,$/;" f +GOMP_offload_register target.c /^GOMP_offload_register (const void *host_table, int target_type,$/;" f +GOMP_offload_register_ver target.c /^GOMP_offload_register_ver (unsigned version, const void *host_table,$/;" f +GOMP_offload_unregister target.c /^GOMP_offload_unregister (const void *host_table, int target_type,$/;" f +GOMP_offload_unregister_ver target.c /^GOMP_offload_unregister_ver (unsigned version, const void *host_table,$/;" f +GOMP_ordered_end ordered.c /^GOMP_ordered_end (void)$/;" f +GOMP_ordered_start ordered.c /^GOMP_ordered_start (void)$/;" f +GOMP_parallel_end parallel.c /^GOMP_parallel_end (void)$/;" f +GOMP_parallel_loop_dynamic loop.c /^GOMP_parallel_loop_dynamic (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_dynamic_start loop.c /^GOMP_parallel_loop_dynamic_start (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_guided loop.c /^GOMP_parallel_loop_guided (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_guided_start loop.c /^GOMP_parallel_loop_guided_start (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_nonmonotonic_dynamic loop.c /^GOMP_parallel_loop_nonmonotonic_dynamic (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_nonmonotonic_guided loop.c /^GOMP_parallel_loop_nonmonotonic_guided (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_runtime loop.c /^GOMP_parallel_loop_runtime (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_runtime_start loop.c /^GOMP_parallel_loop_runtime_start (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_loop_static_start loop.c /^GOMP_parallel_loop_static_start (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_sections_start sections.c /^GOMP_parallel_sections_start (void (*fn) (void *), void *data,$/;" f +GOMP_parallel_start parallel.c /^GOMP_parallel_start (void (*fn) (void *), void *data, unsigned num_threads)$/;" f +GOMP_sections_end sections.c /^GOMP_sections_end (void)$/;" f +GOMP_sections_end_cancel sections.c /^GOMP_sections_end_cancel (void)$/;" f +GOMP_sections_end_nowait sections.c /^GOMP_sections_end_nowait (void)$/;" f +GOMP_sections_next sections.c /^GOMP_sections_next (void)$/;" f +GOMP_sections_start sections.c /^GOMP_sections_start (unsigned count)$/;" f +GOMP_set_tdg_id tdg.c /^void GOMP_set_tdg_id(unsigned int tdg_id)$/;" f +GOMP_single_copy_end single.c /^GOMP_single_copy_end (void *data)$/;" f +GOMP_single_copy_start single.c /^GOMP_single_copy_start (void)$/;" f +GOMP_single_start single.c /^GOMP_single_start (void)$/;" f +GOMP_target target.c /^GOMP_target (int device, void (*fn) (void *), const void *unused,$/;" f +GOMP_target_data target.c /^GOMP_target_data (int device, const void *unused, size_t mapnum,$/;" f +GOMP_target_data_ext target.c /^GOMP_target_data_ext (int device, size_t mapnum, void **hostaddrs,$/;" f +GOMP_target_end_data target.c /^GOMP_target_end_data (void)$/;" f +GOMP_target_enter_exit_data target.c /^GOMP_target_enter_exit_data (int device, size_t mapnum, void **hostaddrs,$/;" f +GOMP_target_ext target.c /^GOMP_target_ext (int device, void (*fn) (void *), size_t mapnum,$/;" f +GOMP_target_update target.c /^GOMP_target_update (int device, const void *unused, size_t mapnum,$/;" f +GOMP_target_update_ext target.c /^GOMP_target_update_ext (int device, size_t mapnum, void **hostaddrs,$/;" f +GOMP_task task.c /^GOMP_task (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *),$/;" f +GOMP_taskgroup_end task.c /^GOMP_taskgroup_end (void)$/;" f +GOMP_taskgroup_start task.c /^GOMP_taskgroup_start (void)$/;" f +GOMP_taskloop task.c 581;" d file: +GOMP_taskloop task.c 585;" d file: +GOMP_taskloop taskloop.c /^GOMP_taskloop (void (*fn) (void *), void *data, void (*cpyfn) (void *, void *),$/;" f +GOMP_taskwait task.c /^GOMP_taskwait (void)$/;" f +GOMP_taskyield task.c /^GOMP_taskyield (void)$/;" f +GOMP_teams config/nvptx/target.c /^GOMP_teams (unsigned int num_teams, unsigned int thread_limit)$/;" f +GOMP_teams target.c /^GOMP_teams (unsigned int num_teams, unsigned int thread_limit)$/;" f +GOMP_unset_tdg_id tdg.c /^GOMP_unset_tdg_id(void)$/;" f +HEIGHT testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 11;" d file: +HELLO testsuite/libgomp.fortran/omp_hello.f /^ PROGRAM HELLO$/;" p +HSA_DEBUG plugin/plugin-hsa.c 293;" d file: +HSA_EXT_AGENT_INFO_IMAGE_1DA_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_1DA_MAX_ELEMENTS = 0x3001,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_1DB_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_1DB_MAX_ELEMENTS = 0x3002,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_1D_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_1D_MAX_ELEMENTS = 0x3000,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_2DADEPTH_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_2DADEPTH_MAX_ELEMENTS = 0x3006,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_2DA_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_2DA_MAX_ELEMENTS = 0x3004,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_2DDEPTH_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_2DDEPTH_MAX_ELEMENTS = 0x3005,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_2D_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_2D_MAX_ELEMENTS = 0x3003,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_3D_MAX_ELEMENTS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_3D_MAX_ELEMENTS = 0x3007,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_IMAGE_ARRAY_MAX_LAYERS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_IMAGE_ARRAY_MAX_LAYERS = 0x3008,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_MAX_IMAGE_RD_HANDLES plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_MAX_IMAGE_RD_HANDLES = 0x3009,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_MAX_IMAGE_RORW_HANDLES plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_MAX_IMAGE_RORW_HANDLES = 0x300A,$/;" e enum:__anon21 +HSA_EXT_AGENT_INFO_MAX_SAMPLER_HANDLERS plugin/hsa_ext_finalize.h /^ HSA_EXT_AGENT_INFO_MAX_SAMPLER_HANDLERS = 0x300B$/;" e enum:__anon21 +HSA_EXT_FINALIZER_CALL_CONVENTION_AUTO plugin/hsa_ext_finalize.h /^ HSA_EXT_FINALIZER_CALL_CONVENTION_AUTO = -1$/;" e enum:__anon17 +HSA_EXT_IMAGE_CAPABILITY_ACCESS_INVARIANT_DATA_LAYOUT plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_ACCESS_INVARIANT_DATA_LAYOUT = 0x10$/;" e enum:__anon14 +HSA_EXT_IMAGE_CAPABILITY_NOT_SUPPORTED plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_NOT_SUPPORTED = 0x0,$/;" e enum:__anon14 +HSA_EXT_IMAGE_CAPABILITY_READ_MODIFY_WRITE plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_READ_MODIFY_WRITE = 0x8,$/;" e enum:__anon14 +HSA_EXT_IMAGE_CAPABILITY_READ_ONLY plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_READ_ONLY = 0x1,$/;" e enum:__anon14 +HSA_EXT_IMAGE_CAPABILITY_READ_WRITE plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_READ_WRITE = 0x4,$/;" e enum:__anon14 +HSA_EXT_IMAGE_CAPABILITY_WRITE_ONLY plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CAPABILITY_WRITE_ONLY = 0x2,$/;" e enum:__anon14 +HSA_EXT_IMAGE_CHANNEL_ORDER_A plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_A = 0,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_ABGR plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_ABGR = 11,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_ARGB plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_ARGB = 10,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_BGRA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_BGRA = 9,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_DEPTH plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_DEPTH = 18,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_DEPTH_STENCIL plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_DEPTH_STENCIL = 19$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_INTENSITY plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_INTENSITY = 16,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_LUMINANCE plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_LUMINANCE = 17,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_R plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_R = 1,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RA = 5,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RG plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RG = 3,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RGB plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RGB = 6,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RGBA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RGBA = 8,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RGBX plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RGBX = 7,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RGX plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RGX = 4,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_RX plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_RX = 2,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_SBGRA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_SBGRA = 15,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_SRGB plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_SRGB = 12,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_SRGBA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_SRGBA = 14,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_ORDER_SRGBX plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_ORDER_SRGBX = 13,$/;" e enum:__anon12 +HSA_EXT_IMAGE_CHANNEL_TYPE_FLOAT plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_FLOAT = 15$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_HALF_FLOAT plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_HALF_FLOAT = 14,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT16 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT16 = 9,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT32 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT32 = 10,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT8 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_SIGNED_INT8 = 8,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_SNORM_INT16 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_SNORM_INT16 = 1,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_SNORM_INT8 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_SNORM_INT8 = 0,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT16 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT16 = 3,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT24 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT24 = 4,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT8 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_INT8 = 2,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_101010 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_101010 = 7,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_555 = 5,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNORM_SHORT_565 = 6,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT16 = 12,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT32 = 13,$/;" e enum:__anon11 +HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8 plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_CHANNEL_TYPE_UNSIGNED_INT8 = 11,$/;" e enum:__anon11 +HSA_EXT_IMAGE_GEOMETRY_1D plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_1D = 0,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_1DA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_1DA = 3,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_1DB plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_1DB = 5,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_2D plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_2D = 1,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_2DA plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_2DA = 4,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_2DADEPTH plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_2DADEPTH = 7$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_2DDEPTH plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_2DDEPTH = 6,$/;" e enum:__anon10 +HSA_EXT_IMAGE_GEOMETRY_3D plugin/hsa_ext_finalize.h /^ HSA_EXT_IMAGE_GEOMETRY_3D = 2,$/;" e enum:__anon10 +HSA_EXT_PROGRAM_INFO_DEFAULT_FLOAT_ROUNDING_MODE plugin/hsa_ext_finalize.h /^ HSA_EXT_PROGRAM_INFO_DEFAULT_FLOAT_ROUNDING_MODE = 2$/;" e enum:__anon18 +HSA_EXT_PROGRAM_INFO_MACHINE_MODEL plugin/hsa_ext_finalize.h /^ HSA_EXT_PROGRAM_INFO_MACHINE_MODEL = 0,$/;" e enum:__anon18 +HSA_EXT_PROGRAM_INFO_PROFILE plugin/hsa_ext_finalize.h /^ HSA_EXT_PROGRAM_INFO_PROFILE = 1,$/;" e enum:__anon18 +HSA_EXT_SAMPLER_ADDRESSING_MODE_CLAMP_TO_BORDER plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_ADDRESSING_MODE_CLAMP_TO_BORDER = 2,$/;" e enum:__anon13 +HSA_EXT_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE = 1,$/;" e enum:__anon13 +HSA_EXT_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT = 4$/;" e enum:__anon13 +HSA_EXT_SAMPLER_ADDRESSING_MODE_REPEAT plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_ADDRESSING_MODE_REPEAT = 3,$/;" e enum:__anon13 +HSA_EXT_SAMPLER_ADDRESSING_MODE_UNDEFINED plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_ADDRESSING_MODE_UNDEFINED = 0,$/;" e enum:__anon13 +HSA_EXT_SAMPLER_COORDINATE_MODE_NORMALIZED plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_COORDINATE_MODE_NORMALIZED = 1$/;" e enum:__anon16 +HSA_EXT_SAMPLER_COORDINATE_MODE_UNNORMALIZED plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_COORDINATE_MODE_UNNORMALIZED = 0,$/;" e enum:__anon16 +HSA_EXT_SAMPLER_FILTER_MODE_LINEAR plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_FILTER_MODE_LINEAR = 1$/;" e enum:__anon15 +HSA_EXT_SAMPLER_FILTER_MODE_NEAREST plugin/hsa_ext_finalize.h /^ HSA_EXT_SAMPLER_FILTER_MODE_NEAREST = 0,$/;" e enum:__anon15 +HSA_EXT_STATUS_ERROR_DIRECTIVE_MISMATCH plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_DIRECTIVE_MISMATCH = 0x2006$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_FINALIZATION_FAILED plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_FINALIZATION_FAILED = 0x2005,$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_IMAGE_FORMAT_UNSUPPORTED plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_IMAGE_FORMAT_UNSUPPORTED = 0x3000,$/;" e enum:__anon19 +HSA_EXT_STATUS_ERROR_IMAGE_SIZE_UNSUPPORTED plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_IMAGE_SIZE_UNSUPPORTED = 0x3001$/;" e enum:__anon19 +HSA_EXT_STATUS_ERROR_INCOMPATIBLE_MODULE plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_INCOMPATIBLE_MODULE = 0x2002,$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_INVALID_MODULE plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_INVALID_MODULE = 0x2001,$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_INVALID_PROGRAM plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_INVALID_PROGRAM = 0x2000,$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_MODULE_ALREADY_INCLUDED plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_MODULE_ALREADY_INCLUDED = 0x2003,$/;" e enum:__anon20 +HSA_EXT_STATUS_ERROR_SYMBOL_MISMATCH plugin/hsa_ext_finalize.h /^ HSA_EXT_STATUS_ERROR_SYMBOL_MISMATCH = 0x2004,$/;" e enum:__anon20 +HSA_LOG plugin/plugin-hsa.c 280;" d file: +HSA_WARNING plugin/plugin-hsa.c 297;" d file: +HTAB_DELETED_ENTRY hashtab.h 61;" d +HTAB_EMPTY_ENTRY hashtab.h 56;" d +I testsuite/libgomp.c++/collapse-2.C /^class I$/;" c file: +I testsuite/libgomp.c++/collapse-2.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/collapse-2.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/collapse-2.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/doacross-1.C /^class I$/;" c file: +I testsuite/libgomp.c++/doacross-1.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/doacross-1.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/doacross-1.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/for-1.C /^class I$/;" c file: +I testsuite/libgomp.c++/for-1.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/for-1.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/for-1.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/for-5.C /^class I$/;" c file: +I testsuite/libgomp.c++/for-5.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/for-5.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/for-5.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/for-8.C /^class I$/;" c file: +I testsuite/libgomp.c++/for-8.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/for-8.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/for-8.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/member-5.C /^class I$/;" c file: +I testsuite/libgomp.c++/member-5.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/member-5.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/member-5.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-6.C /^class I$/;" c file: +I testsuite/libgomp.c++/taskloop-6.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-6.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-6.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-9.C /^class I$/;" c file: +I testsuite/libgomp.c++/taskloop-9.C /^template I::I () : p (0) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-9.C /^template I::I (T *x) : p (x) {}$/;" f class:I +I testsuite/libgomp.c++/taskloop-9.C /^template I::I (const I &x) : p (x.p) {}$/;" f class:I +I testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ IN/;" v program:A16 +I testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ IN/;" v program:A22_7_GOOD +I testsuite/libgomp.fortran/appendix-a/a.26.1.f90 /^ IN/;" v program:A26 +I testsuite/libgomp.fortran/appendix-a/a.28.4.f90 /^ IN/;" v program:A28_4 +I testsuite/libgomp.fortran/omp_orphan.f /^ IN/;" v program:ORPHAN +I testsuite/libgomp.fortran/omp_reduction.f /^ IN/;" v program:REDUCTION +I testsuite/libgomp.fortran/omp_workshare1.f /^ + OMP_GET_THREAD_NUM, N, CHUNKSIZ/;" v program:WORKSHARE1 +I testsuite/libgomp.fortran/omp_workshare2.f /^ IN/;" v program:WORKSHARE2 +I testsuite/libgomp.oacc-c-c++-common/reduction-initial-1.c 6;" d file: +I testsuite/libgomp.oacc-fortran/data-already-1.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-2.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-3.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-4.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-5.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-6.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-7.f /^ IN/;" v +I testsuite/libgomp.oacc-fortran/data-already-8.f /^ IN/;" v +IAM testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ INTEGER IAM,/;" v program:A18 +ID testsuite/libgomp.fortran/appendix-a/a.39.1.f90 /^ INTEGER ID$/;" v program:A39 +INCR testsuite/libgomp.c/loop-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +INCR testsuite/libgomp.c/loop-2.c /^static int INCR, NTHR, CHUNK;$/;" v file: +INCR testsuite/libgomp.c/ordered-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +INCR_A testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ SUBROUTINE INCR_A(/;" s +INCR_B testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ SUBROUTINE INCR_B(/;" s +INCR_PAIR testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ SUBROUTINE INCR_PAIR(/;" s +INDEX testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ INTEGER INDEX(/;" v program:A16 +INLINE_ORDERED_TEAM_IDS_CNT work.c 99;" d file: +INSERT hashtab.h /^enum insert_option {NO_INSERT, INSERT};$/;" e enum:insert_option +INT_MAX testsuite/libgomp.c++/loop-10.C 9;" d file: +INT_MAX testsuite/libgomp.c++/loop-12.C 9;" d file: +INT_MAX testsuite/libgomp.c++/loop-9.C 9;" d file: +INT_MAX testsuite/libgomp.c/loop-12.c 9;" d file: +INT_MAX testsuite/libgomp.c/loop-6.c 9;" d file: +INT_MAX testsuite/libgomp.c/loop-7.c 9;" d file: +ISYNC testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ INTEGER ISYNC(/;" v program:A18 +J testsuite/libgomp.c++/collapse-2.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/collapse-2.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-1.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-1.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-2.C /^ J(T x, T y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-2.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-3.C /^ J(const const_iterator &x, const const_iterator &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-3.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-4.C /^ J(const iterator &x, const iterator &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-4.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-5.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-5.C /^class J$/;" c file: +J testsuite/libgomp.c++/for-8.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/for-8.C /^class J$/;" c file: +J testsuite/libgomp.c++/taskloop-6.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/taskloop-6.C /^class J$/;" c file: +J testsuite/libgomp.c++/taskloop-7.C /^ J(const const_iterator &x, const const_iterator &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/taskloop-7.C /^class J$/;" c file: +J testsuite/libgomp.c++/taskloop-8.C /^ J(const iterator &x, const iterator &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/taskloop-8.C /^class J$/;" c file: +J testsuite/libgomp.c++/taskloop-9.C /^ J(const I &x, const I &y) : b (x), e (y) {}$/;" f class:J +J testsuite/libgomp.c++/taskloop-9.C /^class J$/;" c file: +J testsuite/libgomp.fortran/appendix-a/a.26.1.f90 /^ INTEGER I, J$/;" v program:A26 +J testsuite/libgomp.fortran/appendix-a/a.28.4.f90 /^ INTEGER I, J$/;" v program:A28_4 +K testsuite/libgomp.c++/for-1.C /^struct K$/;" s file: +K testsuite/libgomp.c++/for-3.C /^struct K$/;" s file: +K testsuite/libgomp.c++/for-4.C /^struct K$/;" s file: +K testsuite/libgomp.c++/for-8.C /^struct K$/;" s file: +K testsuite/libgomp.c++/taskloop-6.C /^struct K$/;" s file: +K testsuite/libgomp.c++/taskloop-7.C /^struct K$/;" s file: +K testsuite/libgomp.c++/taskloop-8.C /^struct K$/;" s file: +L testsuite/libgomp.fortran/lib2.f /^ LO/;" v +L testsuite/libgomp.fortran/lib3.f /^ LO/;" v +LCK testsuite/libgomp.fortran/appendix-a/a.39.1.f90 /^ INTEGER(OMP_LOCK_KIND) LCK$/;" v program:A39 +LCK testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ INTEGER (OMP_NEST_LOCK_KIND) LCK$/;" k type:LOCKED_PAIR +LCK testsuite/libgomp.fortran/lib2.f /^ INTEGER (KIND = OMP_LOCK_KIND) :: LCK$/;" v +LCK testsuite/libgomp.fortran/lib3.f /^ INTEGER (KIND = OMP_LOCK_KIND) :: LCK$/;" v +LIBGOMP_GNU_SYMBOL_VERSIONING libgomp.h 1077;" d +LIBGOMP_G_H libgomp_g.h 30;" d +LIBGOMP_H libgomp.h 37;" d +LIBGOMP_PLUGIN_H libgomp-plugin.h 30;" d +LLONG_MAX testsuite/libgomp.c++/loop-10.C 7;" d file: +LLONG_MAX testsuite/libgomp.c++/loop-12.C 7;" d file: +LLONG_MAX testsuite/libgomp.c++/loop-9.C 7;" d file: +LLONG_MAX testsuite/libgomp.c/loop-12.c 7;" d file: +LLONG_MAX testsuite/libgomp.c/loop-6.c 7;" d file: +LLONG_MAX testsuite/libgomp.c/loop-7.c 7;" d file: +LOCKED_PAIR testsuite/libgomp.fortran/appendix-a/a.40.1.f90 /^ TYPE LOCKED_PAIR$/;" t +M testsuite/libgomp.c++/for-10.C 3;" d file: +M testsuite/libgomp.c++/for-11.C 3;" d file: +M testsuite/libgomp.c++/for-12.C 5;" d file: +M testsuite/libgomp.c++/for-13.C 3;" d file: +M testsuite/libgomp.c++/for-14.C 3;" d file: +M testsuite/libgomp.c++/for-9.C 3;" d file: +M testsuite/libgomp.c++/reduction-10.C /^ M () { t = 1; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-10.C /^ M (T x) { t = x; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-10.C /^ M (const M &x) { t = x.t; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-10.C /^struct M$/;" s file: +M testsuite/libgomp.c++/reduction-12.C /^ M () { t = 1; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-12.C /^ M (T x) { t = x; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-12.C /^ M (const M &x) { t = x.t; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-12.C /^struct M$/;" s file: +M testsuite/libgomp.c++/reduction-6.C /^ M () { t = 1; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-6.C /^ M (T x) { t = x; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-6.C /^ M (const M &x) { t = x.t; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-6.C /^struct M$/;" s file: +M testsuite/libgomp.c++/reduction-8.C /^ M () { t = 1; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-8.C /^ M (T x) { t = x; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-8.C /^ M (const M &x) { t = x.t; }$/;" f struct:M +M testsuite/libgomp.c++/reduction-8.C /^struct M$/;" s file: +M testsuite/libgomp.c++/udr-1.C /^ namespace M {}$/;" n namespace:N file: +M testsuite/libgomp.c/examples-4/declare_target-5.c 9;" d file: +M testsuite/libgomp.c/examples-4/simd-4.c 6;" d file: +M testsuite/libgomp.c/examples-4/simd-5.c 6;" d file: +M testsuite/libgomp.c/for-1.c 5;" d file: +M testsuite/libgomp.c/for-2.c 5;" d file: +M testsuite/libgomp.c/for-3.c 5;" d file: +M testsuite/libgomp.c/for-4.c 5;" d file: +M testsuite/libgomp.c/for-5.c 5;" d file: +M testsuite/libgomp.c/for-6.c 5;" d file: +M testsuite/libgomp.fortran/appendix-a/a.31.4.f90 /^ MO/;" m +M testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ integer, parameter :: N = 10000, M /;" v module:e_53_5_mod +M testsuite/libgomp.graphite/force-parallel-6.c 4;" d file: +M testsuite/libgomp.oacc-c-c++-common/routine-4.c 4;" d file: +MAX testsuite/libgomp.c++/loop-1.C 6;" d file: +MAX testsuite/libgomp.c/examples-4/target_data-1.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_data-2.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_data-4.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_data-6.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_data-7.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_update-1.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/examples-4/target_update-2.c /^const int MAX = 1800;$/;" v +MAX testsuite/libgomp.c/omp-loop01.c 6;" d file: +MAX_COLLAPSED_BITS ordered.c 259;" d file: +MEMMODEL_ACQUIRE libgomp.h /^ MEMMODEL_ACQUIRE = 2,$/;" e enum:memmodel +MEMMODEL_ACQ_REL libgomp.h /^ MEMMODEL_ACQ_REL = 4,$/;" e enum:memmodel +MEMMODEL_CONSUME libgomp.h /^ MEMMODEL_CONSUME = 1,$/;" e enum:memmodel +MEMMODEL_RELAXED libgomp.h /^ MEMMODEL_RELAXED = 0,$/;" e enum:memmodel +MEMMODEL_RELEASE libgomp.h /^ MEMMODEL_RELEASE = 3,$/;" e enum:memmodel +MEMMODEL_SEQ_CST libgomp.h /^ MEMMODEL_SEQ_CST = 5$/;" e enum:memmodel +MOD testsuite/libgomp.fortran/appendix-a/a.31.5.f90 /^ MODU/;" m +MONOTONIC_END testsuite/libgomp.c/monotonic-1.c 8;" d file: +MONOTONIC_END testsuite/libgomp.c/monotonic-2.c 7;" d file: +MONOTONIC_TYPE testsuite/libgomp.c/monotonic-1.c 6;" d file: +MONOTONIC_TYPE testsuite/libgomp.c/monotonic-2.c 5;" d file: +MONOTONIC_UNDEF testsuite/libgomp.c/monotonic-1.c 7;" d file: +MONOTONIC_UNDEF testsuite/libgomp.c/monotonic-2.c 6;" d file: +Matrix testsuite/libgomp.hsa.c/tiling-1.c /^} Matrix;$/;" t typeref:struct:__anon23 file: +Matrix testsuite/libgomp.hsa.c/tiling-2.c /^} Matrix;$/;" t typeref:struct:__anon22 file: +N testsuite/libgomp.c++/ctor-10.C 7;" d file: +N testsuite/libgomp.c++/ctor-11.C 7;" d file: +N testsuite/libgomp.c++/ctor-7.C 6;" d file: +N testsuite/libgomp.c++/ctor-8.C 7;" d file: +N testsuite/libgomp.c++/ctor-9.C 7;" d file: +N testsuite/libgomp.c++/examples-4/target_data-5.C 6;" d file: +N testsuite/libgomp.c++/for-10.C 12;" d file: +N testsuite/libgomp.c++/for-10.C 9;" d file: +N testsuite/libgomp.c++/for-11.C 11;" d file: +N testsuite/libgomp.c++/for-11.C 14;" d file: +N testsuite/libgomp.c++/for-11.C 21;" d file: +N testsuite/libgomp.c++/for-11.C 24;" d file: +N testsuite/libgomp.c++/for-11.C 31;" d file: +N testsuite/libgomp.c++/for-11.C 34;" d file: +N testsuite/libgomp.c++/for-11.C 41;" d file: +N testsuite/libgomp.c++/for-11.C 44;" d file: +N testsuite/libgomp.c++/for-12.C 11;" d file: +N testsuite/libgomp.c++/for-12.C 14;" d file: +N testsuite/libgomp.c++/for-12.C 21;" d file: +N testsuite/libgomp.c++/for-12.C 24;" d file: +N testsuite/libgomp.c++/for-13.C 11;" d file: +N testsuite/libgomp.c++/for-13.C 14;" d file: +N testsuite/libgomp.c++/for-13.C 35;" d file: +N testsuite/libgomp.c++/for-13.C 38;" d file: +N testsuite/libgomp.c++/for-13.C 51;" d file: +N testsuite/libgomp.c++/for-13.C 54;" d file: +N testsuite/libgomp.c++/for-13.C 61;" d file: +N testsuite/libgomp.c++/for-13.C 64;" d file: +N testsuite/libgomp.c++/for-13.C 71;" d file: +N testsuite/libgomp.c++/for-13.C 74;" d file: +N testsuite/libgomp.c++/for-13.C 81;" d file: +N testsuite/libgomp.c++/for-13.C 84;" d file: +N testsuite/libgomp.c++/for-14.C 11;" d file: +N testsuite/libgomp.c++/for-14.C 14;" d file: +N testsuite/libgomp.c++/for-14.C 31;" d file: +N testsuite/libgomp.c++/for-14.C 34;" d file: +N testsuite/libgomp.c++/for-14.C 41;" d file: +N testsuite/libgomp.c++/for-14.C 44;" d file: +N testsuite/libgomp.c++/for-14.C 51;" d file: +N testsuite/libgomp.c++/for-14.C 54;" d file: +N testsuite/libgomp.c++/for-14.C 61;" d file: +N testsuite/libgomp.c++/for-14.C 64;" d file: +N testsuite/libgomp.c++/loop-2.C 7;" d file: +N testsuite/libgomp.c++/nested-1.C 4;" d file: +N testsuite/libgomp.c++/sections-1.C 14;" d file: +N testsuite/libgomp.c++/udr-1.C /^namespace N$/;" n file: +N testsuite/libgomp.c/critical-2.c 8;" d file: +N testsuite/libgomp.c/doacross-1.c 3;" d file: +N testsuite/libgomp.c/doacross-2.c 3;" d file: +N testsuite/libgomp.c/doacross-3.c 3;" d file: +N testsuite/libgomp.c/examples-4/async_target-1.c 8;" d file: +N testsuite/libgomp.c/examples-4/async_target-2.c 8;" d file: +N testsuite/libgomp.c/examples-4/declare_target-3.c 6;" d file: +N testsuite/libgomp.c/examples-4/declare_target-4.c 7;" d file: +N testsuite/libgomp.c/examples-4/declare_target-5.c 8;" d file: +N testsuite/libgomp.c/examples-4/device-2.c 7;" d file: +N testsuite/libgomp.c/examples-4/simd-1.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-2.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-3.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-4.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-5.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-6.c 5;" d file: +N testsuite/libgomp.c/examples-4/simd-7.c 8;" d file: +N testsuite/libgomp.c/examples-4/target-1.c 5;" d file: +N testsuite/libgomp.c/examples-4/target-2.c 5;" d file: +N testsuite/libgomp.c/examples-4/target-3.c 5;" d file: +N testsuite/libgomp.c/examples-4/target-4.c 6;" d file: +N testsuite/libgomp.c/examples-4/target-5.c 8;" d file: +N testsuite/libgomp.c/examples-4/task_dep-5.c 3;" d file: +N testsuite/libgomp.c/examples-4/teams-2.c 6;" d file: +N testsuite/libgomp.c/examples-4/teams-3.c 6;" d file: +N testsuite/libgomp.c/examples-4/teams-4.c 6;" d file: +N testsuite/libgomp.c/examples-4/teams-5.c 6;" d file: +N testsuite/libgomp.c/examples-4/teams-6.c 6;" d file: +N testsuite/libgomp.c/for-1.h 10;" d +N testsuite/libgomp.c/for-1.h 12;" d +N testsuite/libgomp.c/for-1.h 15;" d +N testsuite/libgomp.c/for-1.h 17;" d +N testsuite/libgomp.c/for-1.h 20;" d +N testsuite/libgomp.c/for-1.h 22;" d +N testsuite/libgomp.c/for-1.h 25;" d +N testsuite/libgomp.c/for-1.h 2;" d +N testsuite/libgomp.c/for-1.h 5;" d +N testsuite/libgomp.c/for-1.h 7;" d +N testsuite/libgomp.c/for-2.c 11;" d file: +N testsuite/libgomp.c/for-2.c 14;" d file: +N testsuite/libgomp.c/for-3.c 13;" d file: +N testsuite/libgomp.c/for-3.c 16;" d file: +N testsuite/libgomp.c/for-3.c 23;" d file: +N testsuite/libgomp.c/for-3.c 26;" d file: +N testsuite/libgomp.c/for-3.c 33;" d file: +N testsuite/libgomp.c/for-3.c 36;" d file: +N testsuite/libgomp.c/for-3.c 43;" d file: +N testsuite/libgomp.c/for-3.c 46;" d file: +N testsuite/libgomp.c/for-4.c 11;" d file: +N testsuite/libgomp.c/for-4.c 14;" d file: +N testsuite/libgomp.c/for-4.c 21;" d file: +N testsuite/libgomp.c/for-4.c 24;" d file: +N testsuite/libgomp.c/for-5.c 13;" d file: +N testsuite/libgomp.c/for-5.c 16;" d file: +N testsuite/libgomp.c/for-5.c 37;" d file: +N testsuite/libgomp.c/for-5.c 40;" d file: +N testsuite/libgomp.c/for-5.c 53;" d file: +N testsuite/libgomp.c/for-5.c 56;" d file: +N testsuite/libgomp.c/for-5.c 63;" d file: +N testsuite/libgomp.c/for-5.c 66;" d file: +N testsuite/libgomp.c/for-5.c 73;" d file: +N testsuite/libgomp.c/for-5.c 76;" d file: +N testsuite/libgomp.c/for-5.c 83;" d file: +N testsuite/libgomp.c/for-5.c 86;" d file: +N testsuite/libgomp.c/for-6.c 13;" d file: +N testsuite/libgomp.c/for-6.c 16;" d file: +N testsuite/libgomp.c/for-6.c 33;" d file: +N testsuite/libgomp.c/for-6.c 36;" d file: +N testsuite/libgomp.c/for-6.c 43;" d file: +N testsuite/libgomp.c/for-6.c 46;" d file: +N testsuite/libgomp.c/for-6.c 53;" d file: +N testsuite/libgomp.c/for-6.c 56;" d file: +N testsuite/libgomp.c/for-6.c 63;" d file: +N testsuite/libgomp.c/for-6.c 66;" d file: +N testsuite/libgomp.c/loop-1.c 12;" d file: +N testsuite/libgomp.c/loop-2.c 13;" d file: +N testsuite/libgomp.c/omp-loop02.c 7;" d file: +N testsuite/libgomp.c/omp-nested-1.c 4;" d file: +N testsuite/libgomp.c/omp_workshare1.c 15;" d file: +N testsuite/libgomp.c/omp_workshare2.c 14;" d file: +N testsuite/libgomp.c/omp_workshare3.c 16;" d file: +N testsuite/libgomp.c/omp_workshare4.c 15;" d file: +N testsuite/libgomp.c/ordered-1.c 14;" d file: +N testsuite/libgomp.c/ordered-2.c 11;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c 9;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-3.c 8;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-4.c 8;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c 9;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c 9;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c 9;" d file: +N testsuite/libgomp.c/parloops-exit-first-loop-alt.c 9;" d file: +N testsuite/libgomp.c/pr46193.c 38;" d file: +N testsuite/libgomp.c/pr69110.c 4;" d file: +N testsuite/libgomp.c/pr81875.c 9;" d file: +N testsuite/libgomp.c/priority.c 21;" d file: +N testsuite/libgomp.c/sections-1.c 11;" d file: +N testsuite/libgomp.c/target-11.c 6;" d file: +N testsuite/libgomp.c/target-20.c 6;" d file: +N testsuite/libgomp.c/target-9.c 7;" d file: +N testsuite/libgomp.c/target-critical-1.c 6;" d file: +N testsuite/libgomp.fortran/doacross1.f90 /^ integer, parameter :: N /;" v +N testsuite/libgomp.fortran/doacross2.f90 /^ integer, parameter :: N /;" v +N testsuite/libgomp.fortran/doacross3.f90 /^ integer, parameter :: N /;" v +N testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^ integer, parameter :: N /;" v module:e_55_1_mod +N testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^ integer, parameter :: N /;" v program:e_55_2 +N testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^ integer, parameter :: N /;" v module:e_53_3_mod +N testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ integer, parameter :: N /;" v module:e_53_4_mod +N testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ integer, parameter :: N /;" v module:e_53_5_mod +N testsuite/libgomp.fortran/examples-4/device-2.f90 /^ integer, parameter :: N /;" v program:e_57_2 +N testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ integer, parameter :: N=/;" v program:main +N testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ integer,parameter :: N=/;" v program:fibonacci +N testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ integer, parameter :: N /;" v program:e_51_5 +N testsuite/libgomp.fortran/omp_reduction.f /^ INT/;" v program:REDUCTION +N testsuite/libgomp.fortran/omp_workshare1.f /^ + OMP_GET_THREAD_NU/;" v program:WORKSHARE1 +N testsuite/libgomp.fortran/omp_workshare2.f /^ INT/;" v program:WORKSHARE2 +N testsuite/libgomp.fortran/strassen.f90 /^ integer, parameter :: N /;" v program:strassen_matmul +N testsuite/libgomp.graphite/force-parallel-3.c 3;" d file: +N testsuite/libgomp.graphite/force-parallel-4.c 5;" d file: +N testsuite/libgomp.graphite/force-parallel-5.c 4;" d file: +N testsuite/libgomp.graphite/force-parallel-6.c 3;" d file: +N testsuite/libgomp.graphite/force-parallel-7.c 1;" d file: +N testsuite/libgomp.graphite/force-parallel-8.c 1;" d file: +N testsuite/libgomp.graphite/force-parallel-9.c 3;" d file: +N testsuite/libgomp.hsa.c/bits-insns.c 3;" d file: +N testsuite/libgomp.hsa.c/builtins-1.c 6;" d file: +N testsuite/libgomp.oacc-c-c++-common/declare-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/declare-2.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c 109;" d file: +N testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c 67;" d file: +N testsuite/libgomp.oacc-c-c++-common/gang-static-1.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/gang-static-2.c 9;" d file: +N testsuite/libgomp.oacc-c-c++-common/host_data-1.c 32;" d file: +N testsuite/libgomp.oacc-c-c++-common/host_data-4.c 6;" d file: +N testsuite/libgomp.oacc-c-c++-common/host_data-5.c 6;" d file: +N testsuite/libgomp.oacc-c-c++-common/if-1.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-2.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-3.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-2.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-3.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-2.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-3.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-4.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-5.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-6.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-clauses.c 6;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-collapse.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-mod-not-zero.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-n.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop-nest.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/kernels-loop.c 3;" d file: +N testsuite/libgomp.oacc-c-c++-common/lib-88.c /^const int N = 256;$/;" v +N testsuite/libgomp.oacc-c-c++-common/lib-89.c /^const int N = 16;$/;" v +N testsuite/libgomp.oacc-c-c++-common/lib-90.c /^const int N = 16;$/;" v +N testsuite/libgomp.oacc-c-c++-common/lib-92.c /^const int N = 32;$/;" v +N testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c 216;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c 95;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-g-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-g-2.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-gwv-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-g-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-gwv-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-v-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-v-2.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-w-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-w-2.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-red-wv-1.c 6;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-v-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-w-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/loop-wv-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 845;" d file: +N testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 865;" d file: +N testsuite/libgomp.oacc-c-c++-common/nested-2.c 8;" d file: +N testsuite/libgomp.oacc-c-c++-common/parallel-reduction.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/pointer-align-1.c 10;" d file: +N testsuite/libgomp.oacc-c-c++-common/pr70373.c 1;" d file: +N testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c 20;" d file: +N testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c 20;" d file: +N testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c 15;" d file: +N testsuite/libgomp.oacc-c-c++-common/reduction-flt.c 15;" d file: +N testsuite/libgomp.oacc-c-c++-common/reduction-initial-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-4.c 5;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-g-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-gwv-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-v-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-w-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/routine-wv-1.c 7;" d file: +N testsuite/libgomp.oacc-c-c++-common/tile-1.c 249;" d file: +N testsuite/libgomp.oacc-c-c++-common/vector-loop.c 5;" d file: +N testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ integer, parameter :: N /;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^ integer, parameter :: N /;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^ integer, parameter :: N /;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ integer, parameter :: N /;" v program:main +N testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ integer, parameter :: N /;" v program:main +N testsuite/libgomp.oacc-fortran/clauses-1.f90 /^ integer, parameter :: N /;" v program:main +N testsuite/libgomp.oacc-fortran/data-1.f90 /^ integer, parameter :: N /;" v program:test +N testsuite/libgomp.oacc-fortran/data-2.f90 /^ integer, parameter :: N /;" v program:test +N testsuite/libgomp.oacc-fortran/data-3.f90 /^ integer i, N$/;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ integer i, N$/;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/data-4.f90 /^ integer i, N$/;" v program:asyncwait +N testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer, parameter :: N /;" v program:main +N testsuite/libgomp.oacc-fortran/if-1.f90 /^ integer, parameter :: N /;" v program:main +N testsuite/libgomp.oacc-fortran/update-1.f90 /^ integer, parameter :: N /;" v program:update +N1 testsuite/libgomp.c++/udr-6.C /^namespace N1$/;" n file: +N1 testsuite/libgomp.c/pr64868.c /^template $/;" v +N2 testsuite/libgomp.c++/udr-6.C /^namespace N2$/;" n file: +N2 testsuite/libgomp.hsa.c/builtins-1.c 7;" d file: +NDIV2 testsuite/libgomp.oacc-fortran/update-1.f90 /^ integer, parameter :: NDIV2 /;" v program:update +NEIGHBOR testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ INTEGER IAM, NEIGHBOR$/;" v program:A18 +NEW_LOCK testsuite/libgomp.fortran/appendix-a/a.33.3.f90 /^ FUNCTION NEW_LOCK(/;" f +NEW_LOCKS testsuite/libgomp.fortran/appendix-a/a.38.1.f90 /^ FUNCTION NEW_LOCKS(/;" f +NLCK testsuite/libgomp.fortran/lib2.f /^ INTEGER (KIND = OMP_NEST_LOCK_KIND) :: NLCK$/;" v +NLCK testsuite/libgomp.fortran/lib3.f /^ INTEGER (KIND = OMP_NEST_LOCK_KIND) :: NLCK$/;" v +NONMONOTONIC_END testsuite/libgomp.c/nonmonotonic-1.c 7;" d file: +NONMONOTONIC_END testsuite/libgomp.c/nonmonotonic-2.c 6;" d file: +NONMONOTONIC_TYPE testsuite/libgomp.c/nonmonotonic-1.c 6;" d file: +NONMONOTONIC_TYPE testsuite/libgomp.c/nonmonotonic-2.c 5;" d file: +NO_INSERT hashtab.h /^enum insert_option {NO_INSERT, INSERT};$/;" e enum:insert_option +NS testsuite/libgomp.c++/udr-2.C /^namespace NS$/;" n file: +NS testsuite/libgomp.c++/udr-3.C /^namespace NS$/;" n file: +NSECPERSEC testsuite/libgomp.hsa.c/tiling-1.c 14;" d file: +NSECPERSEC testsuite/libgomp.hsa.c/tiling-2.c 14;" d file: +NT testsuite/libgomp.fortran/pr32359.f90 /^ integer, parameter :: NT /;" v +NT testsuite/libgomp.fortran/task3.f90 /^ integer, parameter :: NT /;" v program:F03_2_7_1d +NTHR testsuite/libgomp.c/loop-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +NTHR testsuite/libgomp.c/loop-2.c /^static int INCR, NTHR, CHUNK;$/;" v file: +NTHR testsuite/libgomp.c/ordered-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +NTHR testsuite/libgomp.c/ordered-2.c /^static int CHUNK, NTHR;$/;" v file: +NTHR testsuite/libgomp.c/sections-1.c /^static int NTHR;$/;" v file: +NTHREADS testsuite/libgomp.fortran/omp_hello.f /^ INTEGER NTHREADS,/;" v program:HELLO +NTHREADS testsuite/libgomp.fortran/omp_workshare1.f /^ INTEGER NTHREADS,/;" v program:WORKSHARE1 +NTHREADS testsuite/libgomp.fortran/omp_workshare2.f /^ INTEGER N, I, NTHREADS,/;" v program:WORKSHARE2 +NTHREADS testsuite/libgomp.oacc-c-c++-common/lib-89.c /^const int NTHREADS = 32;$/;" v +NTHREADS testsuite/libgomp.oacc-c-c++-common/lib-90.c /^const int NTHREADS = 32;$/;" v +NTHREADS testsuite/libgomp.oacc-c-c++-common/lib-92.c /^const int NTHREADS = 32;$/;" v +NUMBER_OF_THREADS testsuite/libgomp.c/appendix-a/a.18.1.c 8;" d file: +NUM_GANGS testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 313;" d file: +NUM_GANGS testsuite/libgomp.oacc-c-c++-common/mode-transitions.c 353;" d file: +NUM_VECTORS testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 9;" d file: +NUM_WORKERS testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 8;" d file: +Nupper testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ integer, parameter :: Nupper=/;" v program:firstprivate +O testsuite/libgomp.c++/for-10.C 4;" d file: +O testsuite/libgomp.c++/for-11.C 4;" d file: +O testsuite/libgomp.c++/for-12.C 6;" d file: +O testsuite/libgomp.c++/for-13.C 4;" d file: +O testsuite/libgomp.c++/for-14.C 4;" d file: +O testsuite/libgomp.c++/for-9.C 4;" d file: +O testsuite/libgomp.c/for-1.c 6;" d file: +O testsuite/libgomp.c/for-2.c 6;" d file: +O testsuite/libgomp.c/for-3.c 6;" d file: +O testsuite/libgomp.c/for-4.c 6;" d file: +O testsuite/libgomp.c/for-5.c 6;" d file: +O testsuite/libgomp.c/for-6.c 6;" d file: +OACC_INT_H oacc-int.h 39;" d +OACC_PLUGIN_H oacc-plugin.h 28;" d +OFF testsuite/libgomp.c/examples-4/simd-1.c 6;" d file: +OFFLOAD_TARGET_TYPE_HOST libgomp-plugin.h /^ OFFLOAD_TARGET_TYPE_HOST = 2,$/;" e enum:offload_target_type +OFFLOAD_TARGET_TYPE_HSA libgomp-plugin.h /^ OFFLOAD_TARGET_TYPE_HSA = 7$/;" e enum:offload_target_type +OFFLOAD_TARGET_TYPE_INTEL_MIC libgomp-plugin.h /^ OFFLOAD_TARGET_TYPE_INTEL_MIC = 6,$/;" e enum:offload_target_type +OFFLOAD_TARGET_TYPE_NVIDIA_PTX libgomp-plugin.h /^ OFFLOAD_TARGET_TYPE_NVIDIA_PTX = 5,$/;" e enum:offload_target_type +OFFSET testsuite/libgomp.hsa.c/switch-branch-1.c 36;" d file: +OMPFROM testsuite/libgomp.c++/for-13.C 20;" d file: +OMPFROM testsuite/libgomp.c++/for-13.C 23;" d file: +OMPFROM testsuite/libgomp.c++/for-14.C 21;" d file: +OMPFROM testsuite/libgomp.c++/for-14.C 25;" d file: +OMPFROM testsuite/libgomp.c/for-2.h 21;" d +OMPFROM testsuite/libgomp.c/for-5.c 22;" d file: +OMPFROM testsuite/libgomp.c/for-5.c 25;" d file: +OMPFROM testsuite/libgomp.c/for-6.c 23;" d file: +OMPFROM testsuite/libgomp.c/for-6.c 27;" d file: +OMPTGT testsuite/libgomp.c++/for-14.C 20;" d file: +OMPTGT testsuite/libgomp.c++/for-14.C 24;" d file: +OMPTGT testsuite/libgomp.c/for-2.h 15;" d +OMPTGT testsuite/libgomp.c/for-6.c 22;" d file: +OMPTGT testsuite/libgomp.c/for-6.c 26;" d file: +OMPTO testsuite/libgomp.c++/for-13.C 21;" d file: +OMPTO testsuite/libgomp.c++/for-13.C 24;" d file: +OMPTO testsuite/libgomp.c++/for-14.C 22;" d file: +OMPTO testsuite/libgomp.c++/for-14.C 26;" d file: +OMPTO testsuite/libgomp.c/for-2.h 18;" d +OMPTO testsuite/libgomp.c/for-5.c 23;" d file: +OMPTO testsuite/libgomp.c/for-5.c 26;" d file: +OMPTO testsuite/libgomp.c/for-6.c 24;" d file: +OMPTO testsuite/libgomp.c/for-6.c 28;" d file: +OMP_GET_NUM_THREADS testsuite/libgomp.fortran/omp_hello.f /^ INTEGER NTHREADS, TID, OMP_GET_NUM_THREADS,/;" v program:HELLO +OMP_GET_NUM_THREADS testsuite/libgomp.fortran/omp_workshare1.f /^ INTEGER NTHREADS, TID, OMP_GET_NUM_THREADS,/;" v program:WORKSHARE1 +OMP_GET_NUM_THREADS testsuite/libgomp.fortran/omp_workshare2.f /^ INTEGER N, I, NTHREADS, TID, OMP_GET_NUM_THREADS,/;" v program:WORKSHARE2 +OMP_GET_THREAD_NUM testsuite/libgomp.fortran/omp_hello.f /^ INTEGER NTHREADS, TID, OMP_GET_NUM_THREADS,$/;" v program:HELLO +OMP_GET_THREAD_NUM testsuite/libgomp.fortran/omp_workshare1.f /^ INTEGER NTHREADS, TID, OMP_GET_NUM_THREADS,$/;" v program:WORKSHARE1 +OMP_GET_THREAD_NUM testsuite/libgomp.fortran/omp_workshare2.f /^ INTEGER N, I, NTHREADS, TID, OMP_GET_NUM_THREADS,$/;" v program:WORKSHARE2 +ORPHAN testsuite/libgomp.fortran/omp_orphan.f /^ PROGRAM ORPHAN$/;" p +P testsuite/libgomp.c/examples-4/simd-8.c /^int P[1000];$/;" v +P testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ INTEGER, PO/;" v program:A19 +P testsuite/libgomp.fortran/examples-4/simd-8.f90 /^integer :: P(/;" v module:work +P testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ double precision, pointer :: P(/;" v program:e_51_3 +PQ_CHILDREN priority_queue.h /^ PQ_CHILDREN, \/* Node belongs in parent's children_queue. *\/$/;" e enum:priority_queue_type +PQ_IGNORED priority_queue.h /^ PQ_IGNORED = 999$/;" e enum:priority_queue_type +PQ_TASKGROUP priority_queue.h /^ PQ_TASKGROUP, \/* Node belongs in taskgroup->taskgroup_queue. *\/$/;" e enum:priority_queue_type +PQ_TEAM priority_queue.h /^ PQ_TEAM, \/* Node belongs in gomp_team's task_queue. *\/$/;" e enum:priority_queue_type +PR25162 testsuite/libgomp.fortran/pr25162.f /^ PROGRAM PR25162$/;" p +PRIORITY_INSERT_BEGIN priority_queue.h /^ PRIORITY_INSERT_BEGIN,$/;" e enum:priority_insert_type +PRIORITY_INSERT_END priority_queue.h /^ PRIORITY_INSERT_END$/;" e enum:priority_insert_type +PTR testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ INTEGER, POINTER, SAVE :: PTR$/;" v program:A22_7_GOOD +PTX_EVT_ASYNC_CLEANUP plugin/plugin-nvptx.c /^ PTX_EVT_ASYNC_CLEANUP$/;" e enum:ptx_event_type file: +PTX_EVT_KNL plugin/plugin-nvptx.c /^ PTX_EVT_KNL,$/;" e enum:ptx_event_type file: +PTX_EVT_MEM plugin/plugin-nvptx.c /^ PTX_EVT_MEM,$/;" e enum:ptx_event_type file: +PTX_EVT_SYNC plugin/plugin-nvptx.c /^ PTX_EVT_SYNC,$/;" e enum:ptx_event_type file: +Pfun testsuite/libgomp.c/examples-4/declare_target-4.c /^float Pfun (const int i, const int k)$/;" f +Pfun testsuite/libgomp.c/examples-4/declare_target-5.c /^float Pfun (const int i, const int k)$/;" f +Pfun testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ real function Pfun /;" f module:e_53_4_mod +Pfun testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ real function Pfun /;" f module:e_53_5_mod +Q testsuite/libgomp.c/examples-4/declare_target-4.c /^float Q[N][N];$/;" v +Q testsuite/libgomp.c/examples-4/declare_target-5.c /^float Q[N][N];$/;" v +Q testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ real :: Q(/;" v module:e_53_4_mod +Q testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ real :: Q(/;" v module:e_53_5_mod +Q testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ double precision, pointer :: P(:,:), Q(/;" v program:e_51_3 +R testsuite/libgomp.c++/member-1.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-1.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.c++/member-2.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-2.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.c++/member-3.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-3.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.c++/member-4.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-4.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.c++/member-5.C /^struct R { R () {}; ~R () {}; I r; };$/;" f struct:R +R testsuite/libgomp.c++/member-5.C /^struct R { R () {}; ~R () {}; I r; };$/;" s file: +R testsuite/libgomp.c++/member-6.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-6.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.c++/member-7.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +R testsuite/libgomp.c++/member-7.C /^struct R { R () {}; ~R () {}; int r; };$/;" s file: +R testsuite/libgomp.fortran/appendix-a/a.31.5.f90 /^ RE/;" v program:A31_5 +REDUCTION testsuite/libgomp.fortran/omp_reduction.f /^ PROGRAM REDUCTION$/;" p +REDUCTION_H testsuite/libgomp.oacc-c-c++-common/reduction.h 2;" d +REFCOUNT_INFINITY libgomp.h 878;" d +REFCOUNT_LINK libgomp.h 881;" d +RESULT testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ REAL RESULT(/;" v program:A18 +RESULT testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ INTEGER RESULT,/;" v program:A19 +RETURN_1 testsuite/libgomp.oacc-c++/routine-1-auto.C 7;" d file: +RETURN_1 testsuite/libgomp.oacc-c++/routine-1-template-auto.C 6;" d file: +RETURN_1 testsuite/libgomp.oacc-c++/routine-1-template-trailing-return-type.C 6;" d file: +RETURN_1 testsuite/libgomp.oacc-c++/routine-1-template.C 6;" d file: +RETURN_1 testsuite/libgomp.oacc-c++/routine-1-trailing-return-type.C 7;" d file: +RETURN_1 testsuite/libgomp.oacc-c-c++-common/routine-1.c 7;" d file: +RETURN_2 testsuite/libgomp.oacc-c++/routine-1-auto.C 8;" d file: +RETURN_2 testsuite/libgomp.oacc-c++/routine-1-template-auto.C 7;" d file: +RETURN_2 testsuite/libgomp.oacc-c++/routine-1-template-trailing-return-type.C 7;" d file: +RETURN_2 testsuite/libgomp.oacc-c++/routine-1-template.C 7;" d file: +RETURN_2 testsuite/libgomp.oacc-c++/routine-1-trailing-return-type.C 8;" d file: +RETURN_2 testsuite/libgomp.oacc-c-c++-common/routine-1.c 8;" d file: +ROWS testsuite/libgomp.c/examples-4/target_data-3.c /^const int ROWS = 5;$/;" v +S testsuite/libgomp.c++/cancel-test.h /^ S ()$/;" f struct:S +S testsuite/libgomp.c++/cancel-test.h /^ S (const S &x)$/;" f struct:S +S testsuite/libgomp.c++/cancel-test.h /^ S (int x)$/;" f struct:S +S testsuite/libgomp.c++/cancel-test.h /^struct S$/;" s +S testsuite/libgomp.c++/copyin-2.C /^struct S { int t; char buf[64]; } thr = { 32, "" };$/;" s file: +S testsuite/libgomp.c++/for-10.C 11;" d file: +S testsuite/libgomp.c++/for-10.C 8;" d file: +S testsuite/libgomp.c++/for-11.C 10;" d file: +S testsuite/libgomp.c++/for-11.C 13;" d file: +S testsuite/libgomp.c++/for-11.C 20;" d file: +S testsuite/libgomp.c++/for-11.C 23;" d file: +S testsuite/libgomp.c++/for-11.C 30;" d file: +S testsuite/libgomp.c++/for-11.C 33;" d file: +S testsuite/libgomp.c++/for-11.C 40;" d file: +S testsuite/libgomp.c++/for-11.C 43;" d file: +S testsuite/libgomp.c++/for-12.C 10;" d file: +S testsuite/libgomp.c++/for-12.C 13;" d file: +S testsuite/libgomp.c++/for-12.C 20;" d file: +S testsuite/libgomp.c++/for-12.C 23;" d file: +S testsuite/libgomp.c++/for-13.C 10;" d file: +S testsuite/libgomp.c++/for-13.C 13;" d file: +S testsuite/libgomp.c++/for-13.C 34;" d file: +S testsuite/libgomp.c++/for-13.C 37;" d file: +S testsuite/libgomp.c++/for-13.C 50;" d file: +S testsuite/libgomp.c++/for-13.C 53;" d file: +S testsuite/libgomp.c++/for-13.C 60;" d file: +S testsuite/libgomp.c++/for-13.C 63;" d file: +S testsuite/libgomp.c++/for-13.C 70;" d file: +S testsuite/libgomp.c++/for-13.C 73;" d file: +S testsuite/libgomp.c++/for-13.C 80;" d file: +S testsuite/libgomp.c++/for-13.C 83;" d file: +S testsuite/libgomp.c++/for-14.C 10;" d file: +S testsuite/libgomp.c++/for-14.C 13;" d file: +S testsuite/libgomp.c++/for-14.C 30;" d file: +S testsuite/libgomp.c++/for-14.C 33;" d file: +S testsuite/libgomp.c++/for-14.C 40;" d file: +S testsuite/libgomp.c++/for-14.C 43;" d file: +S testsuite/libgomp.c++/for-14.C 50;" d file: +S testsuite/libgomp.c++/for-14.C 53;" d file: +S testsuite/libgomp.c++/for-14.C 60;" d file: +S testsuite/libgomp.c++/for-14.C 63;" d file: +S testsuite/libgomp.c++/pr26943.C /^ S () : x(-1) { }$/;" f struct:S +S testsuite/libgomp.c++/pr26943.C /^S::S (const S &s)$/;" f class:S +S testsuite/libgomp.c++/pr26943.C /^struct S$/;" s file: +S testsuite/libgomp.c++/pr27337.C /^S::S () : i(18)$/;" f class:S +S testsuite/libgomp.c++/pr27337.C /^S::S (const S &x)$/;" f class:S +S testsuite/libgomp.c++/pr27337.C /^struct S$/;" s file: +S testsuite/libgomp.c++/pr35185.C /^ S () : s (6) {}$/;" f struct:S +S testsuite/libgomp.c++/pr35185.C /^struct S$/;" s file: +S testsuite/libgomp.c++/pr66702-2.C /^struct S { int s1, s2; };$/;" s file: +S testsuite/libgomp.c++/pr81314.C /^ S () { s = 0; }$/;" f struct:S +S testsuite/libgomp.c++/pr81314.C /^ S (const S &x) { s = x.s; }$/;" f struct:S +S testsuite/libgomp.c++/pr81314.C /^struct S {$/;" s file: +S testsuite/libgomp.c++/reduction-10.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b() {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-10.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-11.C /^ S() : x(p3), y(y3), w(w3), z(), a(), b(bb) {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-11.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-12.C /^ S() : x(p3), y(y3), w(w3), z(), a(), b() {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-12.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-5.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b(bb) {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-5.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-6.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b() {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-6.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-7.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b(bb) {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-7.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-8.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b() {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-8.C /^struct S$/;" s file: +S testsuite/libgomp.c++/reduction-9.C /^ S() : x(p3), y(y3+1), w(w3), z(), a(), b(bb) {}$/;" f struct:S +S testsuite/libgomp.c++/reduction-9.C /^struct S$/;" s file: +S testsuite/libgomp.c++/simd-4.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-4.C /^struct S$/;" s file: +S testsuite/libgomp.c++/simd-5.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-5.C /^struct S$/;" s file: +S testsuite/libgomp.c++/simd-6.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-6.C /^ S (int x) : s (x) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-6.C /^struct S$/;" s file: +S testsuite/libgomp.c++/simd-7.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-7.C /^ S (int x) : s (x) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-7.C /^struct S$/;" s file: +S testsuite/libgomp.c++/simd-8.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/simd-8.C /^struct S$/;" s file: +S testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" s file: +S testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" s file: +S testsuite/libgomp.c++/target-12.C /^struct S { int s; int *u; int v[5]; };$/;" s file: +S testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" s file: +S testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" s file: +S testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" s file: +S testsuite/libgomp.c++/target-19.C /^struct S { char a[64]; int (&r)[2]; char b[64]; };$/;" s file: +S testsuite/libgomp.c++/target-20.C /^struct S { int a, b, c, d; };$/;" s file: +S testsuite/libgomp.c++/target-21.C /^S::S () : x (xt), y (yp), z (zt)$/;" f class:S +S testsuite/libgomp.c++/target-21.C /^struct S { int (&x)[10]; int *&y; T t; int &z; S (); ~S (); };$/;" s file: +S testsuite/libgomp.c++/target-6.C /^struct S { int s, t; };$/;" s file: +S testsuite/libgomp.c++/target-8.C /^struct S { int a; };$/;" s file: +S testsuite/libgomp.c++/udr-1.C /^ S () { s = 6; }$/;" f struct:S +S testsuite/libgomp.c++/udr-1.C /^ S (const S &x) { s = x.s + 1; }$/;" f struct:S +S testsuite/libgomp.c++/udr-1.C /^ S (const S &x, bool y) { s = x.s + 2; if (y) abort (); }$/;" f struct:S +S testsuite/libgomp.c++/udr-1.C /^struct S$/;" s file: +S testsuite/libgomp.c++/udr-2.C /^ S () { s = 6; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-2.C /^ S (const S &x) { s = x.s + 1; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-2.C /^ S (const S &x, bool y) { s = x.s + 2; if (y) abort (); }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-2.C /^ S (int x) { s = x; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-2.C /^ struct S$/;" s namespace:NS file: +S testsuite/libgomp.c++/udr-3.C /^ S () { s = 6; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-3.C /^ S (const S &x) { s = x.s + 1; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-3.C /^ S (const S &x, bool y) { s = x.s + 2; if (y) abort (); }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-3.C /^ S (int x) { s = x; }$/;" f struct:NS::S +S testsuite/libgomp.c++/udr-3.C /^ struct S$/;" s namespace:NS file: +S testsuite/libgomp.c++/udr-4.C /^ S () : s (0) {}$/;" f struct:S +S testsuite/libgomp.c++/udr-4.C /^struct S$/;" s file: +S testsuite/libgomp.c++/udr-5.C /^ S () : a (0) {}$/;" f struct:S +S testsuite/libgomp.c++/udr-5.C /^struct S$/;" s file: +S testsuite/libgomp.c++/udr-7.C /^ S () { s = 6; }$/;" f struct:S +S testsuite/libgomp.c++/udr-7.C /^ S (const S &x) { s = x.s + 1; }$/;" f struct:S +S testsuite/libgomp.c++/udr-7.C /^struct S$/;" s file: +S testsuite/libgomp.c++/udr-8.C /^struct S { int s; S () : s (0) {} };$/;" f struct:S +S testsuite/libgomp.c++/udr-8.C /^struct S { int s; S () : s (0) {} };$/;" s file: +S testsuite/libgomp.c/for-1.h 11;" d +S testsuite/libgomp.c/for-1.h 14;" d +S testsuite/libgomp.c/for-1.h 16;" d +S testsuite/libgomp.c/for-1.h 19;" d +S testsuite/libgomp.c/for-1.h 1;" d +S testsuite/libgomp.c/for-1.h 21;" d +S testsuite/libgomp.c/for-1.h 24;" d +S testsuite/libgomp.c/for-1.h 4;" d +S testsuite/libgomp.c/for-1.h 6;" d +S testsuite/libgomp.c/for-1.h 9;" d +S testsuite/libgomp.c/for-2.c 10;" d file: +S testsuite/libgomp.c/for-2.c 13;" d file: +S testsuite/libgomp.c/for-3.c 12;" d file: +S testsuite/libgomp.c/for-3.c 15;" d file: +S testsuite/libgomp.c/for-3.c 22;" d file: +S testsuite/libgomp.c/for-3.c 25;" d file: +S testsuite/libgomp.c/for-3.c 32;" d file: +S testsuite/libgomp.c/for-3.c 35;" d file: +S testsuite/libgomp.c/for-3.c 42;" d file: +S testsuite/libgomp.c/for-3.c 45;" d file: +S testsuite/libgomp.c/for-4.c 10;" d file: +S testsuite/libgomp.c/for-4.c 13;" d file: +S testsuite/libgomp.c/for-4.c 20;" d file: +S testsuite/libgomp.c/for-4.c 23;" d file: +S testsuite/libgomp.c/for-5.c 12;" d file: +S testsuite/libgomp.c/for-5.c 15;" d file: +S testsuite/libgomp.c/for-5.c 36;" d file: +S testsuite/libgomp.c/for-5.c 39;" d file: +S testsuite/libgomp.c/for-5.c 52;" d file: +S testsuite/libgomp.c/for-5.c 55;" d file: +S testsuite/libgomp.c/for-5.c 62;" d file: +S testsuite/libgomp.c/for-5.c 65;" d file: +S testsuite/libgomp.c/for-5.c 72;" d file: +S testsuite/libgomp.c/for-5.c 75;" d file: +S testsuite/libgomp.c/for-5.c 82;" d file: +S testsuite/libgomp.c/for-5.c 85;" d file: +S testsuite/libgomp.c/for-6.c 12;" d file: +S testsuite/libgomp.c/for-6.c 15;" d file: +S testsuite/libgomp.c/for-6.c 32;" d file: +S testsuite/libgomp.c/for-6.c 35;" d file: +S testsuite/libgomp.c/for-6.c 42;" d file: +S testsuite/libgomp.c/for-6.c 45;" d file: +S testsuite/libgomp.c/for-6.c 52;" d file: +S testsuite/libgomp.c/for-6.c 55;" d file: +S testsuite/libgomp.c/for-6.c 62;" d file: +S testsuite/libgomp.c/for-6.c 65;" d file: +S testsuite/libgomp.c/loop-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +S testsuite/libgomp.c/ordered-1.c /^static int S, E, INCR, CHUNK, NTHR;$/;" v file: +S testsuite/libgomp.c/simd-4.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/simd-5.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/simd-6.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/simd-8.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/simd-9.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/target-13.c /^struct S { int s, t; };$/;" s file: +S testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" s file: +S testsuite/libgomp.c/target-22.c /^struct S { int *s; char *u; struct T v; short *w; };$/;" s file: +S testsuite/libgomp.c/target-23.c /^struct S { int s; int *u; int v[5]; };$/;" s file: +S testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" s file: +S testsuite/libgomp.c/target-link-1.c /^struct S { int s, t; };$/;" s file: +S testsuite/libgomp.c/udr-1.c /^struct S { int s; struct S *t; };$/;" s file: +S testsuite/libgomp.c/udr-2.c /^struct S { int s; };$/;" s file: +S testsuite/libgomp.c/udr-3.c /^struct S { int s; };$/;" s file: +S1 testsuite/libgomp.hsa.c/bitfield-1.c /^struct S1$/;" s file: +S2 testsuite/libgomp.hsa.c/bitfield-1.c /^struct S2$/;" s file: +S3 testsuite/libgomp.hsa.c/bitfield-1.c /^struct S3$/;" s file: +S4 testsuite/libgomp.hsa.c/bitfield-1.c /^struct S4$/;" s file: +S5 testsuite/libgomp.hsa.c/bitfield-1.c /^struct S5$/;" s file: +SAFELEN testsuite/libgomp.c/examples-4/simd-4.c 8;" d file: +SAFELEN testsuite/libgomp.c/examples-4/simd-5.c 8;" d file: +SC testsuite/libgomp.c++/for-10.C 22;" d file: +SC testsuite/libgomp.c++/for-10.C 23;" d file: +SC testsuite/libgomp.c++/for-10.C 29;" d file: +SC testsuite/libgomp.c/for-2.c 24;" d file: +SC testsuite/libgomp.c/for-2.c 25;" d file: +SC testsuite/libgomp.c/for-2.c 31;" d file: +SC testsuite/libgomp.c/for-2.h 12;" d +SEM_INC config/linux/sem.h 40;" d +SEM_WAIT config/linux/sem.h 39;" d +SIMD1 testsuite/libgomp.fortran/examples-4/simd-1.f90 /^program SIMD1$/;" p +SIMD1_mod testsuite/libgomp.fortran/examples-4/simd-1.f90 /^module SIMD1_mod$/;" m +SIMD2_mod testsuite/libgomp.fortran/examples-4/simd-2.f90 /^module SIMD2_mod$/;" m +SIMD3 testsuite/libgomp.fortran/examples-4/simd-3.f90 /^program SIMD3$/;" p +SIMD3_mod testsuite/libgomp.fortran/examples-4/simd-3.f90 /^module SIMD3_mod$/;" m +SIMD4 testsuite/libgomp.fortran/examples-4/simd-4.f90 /^program SIMD4$/;" p +SIMD4_mod testsuite/libgomp.fortran/examples-4/simd-4.f90 /^module SIMD4_mod$/;" m +SIMD5 testsuite/libgomp.fortran/examples-4/simd-5.f90 /^program SIMD5$/;" p +SIMD5_mod testsuite/libgomp.fortran/examples-4/simd-5.f90 /^module SIMD5_mod$/;" m +SIMD6 testsuite/libgomp.fortran/examples-4/simd-6.f90 /^program SIMD6$/;" p +SIMD6_mod testsuite/libgomp.fortran/examples-4/simd-6.f90 /^module SIMD6_mod$/;" m +SIZE testsuite/libgomp.c/omp_matvec.c 16;" d file: +SKIP testsuite/libgomp.fortran/appendix-a/a.39.1.f90 /^ SUBROUTINE SKIP(/;" s +SONAME_SUFFIX config/darwin/plugin-suffix.h 26;" d +SONAME_SUFFIX config/hpux/plugin-suffix.h 26;" d +SONAME_SUFFIX config/posix/plugin-suffix.h 26;" d +STACK_SIZE testsuite/libgomp.c/sort-1.c 67;" d file: +STATIC_TDG tdg.h 4;" d +SUB testsuite/libgomp.fortran/appendix-a/a.28.1.f90 /^ SUBR/;" s +SUB testsuite/libgomp.fortran/appendix-a/a.28.2.f90 /^ SUBR/;" s program:A28_2 +SUB testsuite/libgomp.fortran/appendix-a/a.4.1.f90 /^ SUBR/;" s +SUB1 testsuite/libgomp.fortran/appendix-a/a.15.1.f90 /^ SUBROUTINE SUB1(/;" s +SUB1 testsuite/libgomp.fortran/appendix-a/a.22.8.f90 /^ SUBROUTINE SUB1(/;" s +SUB1 testsuite/libgomp.fortran/appendix-a/a.28.5.f90 /^ SUBROUTINE SUB1(/;" s +SUB2 testsuite/libgomp.fortran/appendix-a/a.15.1.f90 /^ SUBROUTINE SUB2(/;" s +SUB2 testsuite/libgomp.fortran/appendix-a/a.22.8.f90 /^ SUBROUTINE SUB2(/;" s +SUB3 testsuite/libgomp.fortran/appendix-a/a.15.1.f90 /^ SUBROUTINE SUB3(/;" s +SUBA16 testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ SUBROUTINE SUBA16(/;" s +SUBA21 testsuite/libgomp.fortran/appendix-a/a.21.1.f90 /^ SUBROUTINE SUBA21(/;" s +SUBDOMAIN testsuite/libgomp.fortran/appendix-a/a.4.1.f90 /^ SUBROUTINE SUBDOMAIN(/;" s +SUM testsuite/libgomp.fortran/omp_orphan.f /^ REAL*8 A(VECLEN), B(VECLEN), SUM$/;" v program:ORPHAN +SUM testsuite/libgomp.fortran/omp_reduction.f /^ REAL A(100), B(100), SUM$/;" v program:REDUCTION +SYSCALL_STRING config/linux/sparc/futex.h 46;" d +SYS_futex config/linux/alpha/futex.h 29;" d +SYS_futex config/linux/mips/futex.h 31;" d +SYS_futex config/linux/x86/futex.h 30;" d +SYS_futex config/linux/x86/futex.h 79;" d +T testsuite/libgomp.c++/member-1.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +T testsuite/libgomp.c++/member-1.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" s file: +T testsuite/libgomp.c++/member-2.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +T testsuite/libgomp.c++/member-2.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" s file: +T testsuite/libgomp.c++/member-3.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +T testsuite/libgomp.c++/member-3.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" s file: +T testsuite/libgomp.c++/member-4.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +T testsuite/libgomp.c++/member-4.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" s file: +T testsuite/libgomp.c++/member-5.C /^struct T { T () {}; virtual ~T () {}; I t; };$/;" f struct:T +T testsuite/libgomp.c++/member-5.C /^struct T { T () {}; virtual ~T () {}; I t; };$/;" s file: +T testsuite/libgomp.c++/member-6.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +T testsuite/libgomp.c++/member-6.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" s file: +T testsuite/libgomp.c++/member-7.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +T testsuite/libgomp.c++/member-7.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" s file: +T testsuite/libgomp.c++/pr66702-2.C /^T::T () : t(0) {}$/;" f class:T +T testsuite/libgomp.c++/pr66702-2.C /^struct T { T (); ~T (); int t; };$/;" s file: +T testsuite/libgomp.c++/target-10.C /^struct T { int a; union U b; int c; };$/;" s file: +T testsuite/libgomp.c++/target-11.C /^struct T { int a; int *b; int c; char (&d)[10]; };$/;" s file: +T testsuite/libgomp.c++/target-21.C /^struct T { char t[270]; };$/;" s file: +T testsuite/libgomp.c++/target-8.C /^typedef __int128 T;$/;" t file: +T testsuite/libgomp.c++/target-8.C /^typedef long long int T;$/;" t file: +T testsuite/libgomp.c++/udr-2.C /^struct T : public NS::S$/;" s file: +T testsuite/libgomp.c++/udr-3.C /^struct T : public NS::S$/;" s file: +T testsuite/libgomp.c++/udr-5.C /^ T () : a (N) {}$/;" f struct:T +T testsuite/libgomp.c++/udr-5.C /^struct T$/;" s file: +T testsuite/libgomp.c/cancel-taskgroup-1.c /^struct T { struct T *children[2]; int val; };$/;" s file: +T testsuite/libgomp.c/pr64868.c /^template $/;" v +T testsuite/libgomp.c/target-21.c /^struct T { int a; union U b; int c; };$/;" s file: +T testsuite/libgomp.c/target-22.c /^struct T { int a; int *b; int c; };$/;" s file: +T testsuite/libgomp.graphite/force-parallel-4.c 6;" d file: +T testsuite/libgomp.hsa.c/rotate-1.c 4;" d file: +TARG testsuite/libgomp.fortran/appendix-a/a.22.7.f90 /^ INTEGER, TARGE/;" v program:A22_7_GOOD +TDG_C tdg.c 5;" d file: +TDG_DYNAMIC_SCHED_DYNAMIC tdg.h /^ TDG_DYNAMIC_SCHED_DYNAMIC,$/;" e enum:gomp_tdg_type +TDG_H tdg.h 2;" d +TDG_HASH_SIZE tdg.h 7;" d +TDG_STATIC_SCHED_DYNAMIC tdg.h /^ TDG_STATIC_SCHED_DYNAMIC,$/;" e enum:gomp_tdg_type +TDG_STATIC_SCHED_STATIC tdg.h /^ TDG_STATIC_SCHED_STATIC$/;" e enum:gomp_tdg_type +TEMPLATE testsuite/libgomp.oacc-c++/routine-1-auto.C 5;" d file: +TEMPLATE testsuite/libgomp.oacc-c++/routine-1-template-auto.C 5;" d file: +TEMPLATE testsuite/libgomp.oacc-c++/routine-1-template-trailing-return-type.C 5;" d file: +TEMPLATE testsuite/libgomp.oacc-c++/routine-1-template.C 5;" d file: +TEMPLATE testsuite/libgomp.oacc-c++/routine-1-trailing-return-type.C 5;" d file: +TEMPLATE testsuite/libgomp.oacc-c-c++-common/routine-1.c 5;" d file: +TEST testsuite/libgomp.c++/linear-1.C 228;" d file: +TEST testsuite/libgomp.c/linear-1.c 222;" d file: +TEST testsuite/libgomp.hsa.c/complex-1.c /^TEST (uchar)$/;" f +TEST testsuite/libgomp.hsa.c/complex-1.c 8;" d file: +TEST1 testsuite/libgomp.fortran/pr25162.f /^ SUBROUTINE TEST1$/;" s +TEST2 testsuite/libgomp.fortran/pr25162.f /^ SUBROUTINE TEST2$/;" s +TEST3 testsuite/libgomp.fortran/pr25162.f /^ SUBROUTINE TEST3$/;" s +TESTCOM testsuite/libgomp.fortran/pr25162.f 10;" c subroutine:TEST1 +TESTCOM testsuite/libgomp.fortran/pr25162.f 20;" c subroutine:TEST2 +TESTCOM testsuite/libgomp.fortran/pr25162.f 33;" c subroutine:TEST3 +TESTITERS testsuite/libgomp.c/examples-4/declare_target-4.c 9;" d file: +TEST_BIT_BUILTINS testsuite/libgomp.hsa.c/builtins-1.c 14;" d file: +THE_LOOP testsuite/libgomp.hsa.c/gridify-3.c 1;" d file: +THE_LOOP testsuite/libgomp.hsa.c/gridify-4.c 1;" d file: +THR testsuite/libgomp.c++/ctor-10.C 8;" d file: +THR testsuite/libgomp.c++/ctor-8.C 8;" d file: +THR testsuite/libgomp.c++/ctor-9.C 8;" d file: +THRESHOLD testsuite/libgomp.c/examples-4/declare_target-1.c 5;" d file: +THRESHOLD testsuite/libgomp.c/examples-4/target_data-6.c 8;" d file: +THRESHOLD testsuite/libgomp.c/examples-4/target_data-7.c 7;" d file: +THRESHOLD testsuite/libgomp.c/sort-1.c 27;" d file: +THRESHOLD testsuite/libgomp.fortran/examples-4/declare_target-1.f90 /^ integer :: THRESHOLD /;" v module:e_53_1_mod +THRESHOLD testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^integer, parameter :: THRESHOLD /;" v module:e_51_6_mod +THRESHOLD testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^integer, parameter :: THRESHOLD /;" v module:e_51_7_mod +THRESHOLD1 testsuite/libgomp.c/examples-4/target-5.c 9;" d file: +THRESHOLD1 testsuite/libgomp.fortran/examples-4/target-5.f90 /^integer, parameter :: THRESHOLD1 /;" v module:e_50_5_mod +THRESHOLD2 testsuite/libgomp.c/examples-4/target-5.c 10;" d file: +THRESHOLD2 testsuite/libgomp.fortran/examples-4/target-5.f90 /^integer, parameter :: THRESHOLD1 = 500, THRESHOLD2 /;" v module:e_50_5_mod +TID testsuite/libgomp.fortran/omp_hello.f /^ INTEGER NTHREADS, TID,/;" v program:HELLO +TID testsuite/libgomp.fortran/omp_workshare1.f /^ INTEGER NTHREADS, TID,/;" v program:WORKSHARE1 +TID testsuite/libgomp.fortran/omp_workshare2.f /^ INTEGER N, I, NTHREADS, TID,/;" v program:WORKSHARE2 +TMPL_1 testsuite/libgomp.c/loop-1.c 47;" d file: +TMPL_1 testsuite/libgomp.c/ordered-1.c 49;" d file: +TMPL_1 testsuite/libgomp.c/ordered-2.c 27;" d file: +TMPL_2 testsuite/libgomp.c/loop-1.c 74;" d file: +TO_INT fortran.c 261;" d file: +TYPE task.c 571;" d file: +TYPE task.c 575;" d file: +TYPE task.c 579;" d file: +TYPE task.c 583;" d file: +TYPE testsuite/libgomp.oacc-c++/routine-1-auto.C 6;" d file: +TYPE testsuite/libgomp.oacc-c++/routine-1-trailing-return-type.C 6;" d file: +TYPE testsuite/libgomp.oacc-c-c++-common/routine-1.c 6;" d file: +TYPE_is_long task.c 573;" d file: +TYPE_is_long task.c 577;" d file: +Type testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^typedef double _Complex Type;$/;" t file: +Type testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^typedef float _Complex Type;$/;" t file: +Type testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^typedef double Type;$/;" t file: +Type testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^typedef float Type;$/;" t file: +U testsuite/libgomp.c++/member-5.C /^struct U { U () {}; virtual ~U () {}; Q t; };$/;" f struct:U +U testsuite/libgomp.c++/member-5.C /^struct U { U () {}; virtual ~U () {}; Q t; };$/;" s file: +U testsuite/libgomp.c++/simd-1.C /^U::U () : u (6)$/;" f class:U +U testsuite/libgomp.c++/simd-1.C /^struct U { U (); ~U (); int u; };$/;" s file: +U testsuite/libgomp.c++/target-10.C /^union U { int x; long long y; };$/;" u file: +U testsuite/libgomp.c++/udr-2.C /^ struct U$/;" s namespace:NS file: +U testsuite/libgomp.c++/udr-3.C /^ struct U$/;" s namespace:NS file: +U testsuite/libgomp.c/simd-1.c /^struct U { int u; };$/;" s file: +U testsuite/libgomp.c/simd-7.c /^struct U { int u; };$/;" s file: +U testsuite/libgomp.c/target-21.c /^union U { int x; long long y; };$/;" u file: +ULLONG_MAX testsuite/libgomp.c++/loop-10.C 8;" d file: +ULLONG_MAX testsuite/libgomp.c++/loop-12.C 8;" d file: +ULLONG_MAX testsuite/libgomp.c++/loop-9.C 8;" d file: +ULLONG_MAX testsuite/libgomp.c/loop-12.c 8;" d file: +ULLONG_MAX testsuite/libgomp.c/loop-6.c 8;" d file: +ULLONG_MAX testsuite/libgomp.c/loop-7.c 8;" d file: +UTYPE task.c 572;" d file: +UTYPE task.c 576;" d file: +UTYPE task.c 580;" d file: +UTYPE task.c 584;" d file: +V testsuite/libgomp.c++/simd-1.C /^ V () : v (8) {}$/;" f struct:V +V testsuite/libgomp.c++/simd-1.C /^struct V$/;" s file: +V testsuite/libgomp.c++/udr-3.C /^ V () : v (4) {}$/;" f struct:V +V testsuite/libgomp.c++/udr-3.C /^ V (int x) : v (x) {}$/;" f struct:V +V testsuite/libgomp.c++/udr-3.C /^struct V$/;" s file: +V testsuite/libgomp.c/simd-1.c /^struct V { int v; };$/;" s file: +V testsuite/libgomp.c/simd-7.c /^struct V { int v; };$/;" s file: +VARS testsuite/libgomp.c/for-2.h 2;" d +VECLEN testsuite/libgomp.c/omp_orphan.c 13;" d file: +VECLEN testsuite/libgomp.fortran/omp_orphan.f /^ INTEGER I, VECLEN$/;" v program:ORPHAN +VEC_ID testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 18;" d file: +W testsuite/libgomp.c++/udr-3.C /^ W () : v (6) {}$/;" f struct:W +W testsuite/libgomp.c++/udr-3.C /^struct W$/;" s file: +WARRANTY openacc_lib.h /^! WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS$/;" v +WIDTH testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 10;" d file: +WORK testsuite/libgomp.fortran/appendix-a/a.15.1.f90 /^ SUBROUTINE WORK(/;" s +WORK testsuite/libgomp.fortran/appendix-a/a.18.1.f90 /^ REAL WORK(/;" v program:A18 +WORK testsuite/libgomp.fortran/appendix-a/a.21.1.f90 /^ SUBROUTINE WORK(/;" s +WORK testsuite/libgomp.fortran/appendix-a/a.22.8.f90 /^ REAL, POINTER :: WORK(/;" v module:A22_MODULE8 +WORK testsuite/libgomp.fortran/appendix-a/a.39.1.f90 /^ SUBROUTINE WORK(/;" s +WORK1 testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ REAL FUNCTION WORK1(/;" f +WORK1 testsuite/libgomp.fortran/appendix-a/a10.1.f90 /^ SUBROUTINE WORK1(/;" s +WORK2 testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ REAL FUNCTION WORK2(/;" f +WORK2 testsuite/libgomp.fortran/appendix-a/a10.1.f90 /^ SUBROUTINE WORK2(/;" s +WORKSHARE1 testsuite/libgomp.fortran/omp_workshare1.f /^ PROGRAM WORKSHARE1$/;" p +WORKSHARE2 testsuite/libgomp.fortran/omp_workshare2.f /^ PROGRAM WORKSHARE2$/;" p +WORK_ID testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c 13;" d file: +WorkVec testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c /^ WorkVec (int *ptr, int w, int h, int nw, int nv)$/;" f +X testsuite/libgomp.c++/shared-1.C /^struct X$/;" s file: +X testsuite/libgomp.c++/single-2.C /^struct X$/;" s file: +X testsuite/libgomp.c/omp-single-2.c /^struct X$/;" s file: +X testsuite/libgomp.c/shared-1.c /^struct X$/;" s file: +X testsuite/libgomp.c/target-9.c /^int X, Y;$/;" v +X testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ REAL X(/;" v program:A16 +X testsuite/libgomp.fortran/appendix-a/a.19.1.f90 /^ INTEGER, TARGET :: X$/;" v program:A19 +X testsuite/libgomp.fortran/appendix-a/a.2.1.f90 /^ INTEGER X$/;" v program:A2 +X testsuite/libgomp.graphite/force-parallel-6.c /^int X[2*N], Y[2*N], B[2*N];$/;" v +Y testsuite/libgomp.c++/shared-1.C /^struct Y$/;" s file: +Y testsuite/libgomp.c/examples-4/async_target-1.c /^float Y[N];$/;" v +Y testsuite/libgomp.c/shared-1.c /^struct Y$/;" s file: +Y testsuite/libgomp.c/target-9.c /^int X, Y;$/;" v +Y testsuite/libgomp.fortran/appendix-a/a.16.1.f90 /^ REAL X(1000), Y(/;" v program:A16 +Y testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^ real :: Y(/;" v module:e_55_1_mod +Y testsuite/libgomp.graphite/force-parallel-6.c /^int X[2*N], Y[2*N], B[2*N];$/;" v +Z testsuite/libgomp.c/examples-4/async_target-1.c /^float Z[N];$/;" v +Z testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^ real :: Y(N), Z(/;" v module:e_55_1_mod +Z testsuite/libgomp.graphite/force-parallel-3.c /^int Z[2*N+2][2*N+2], B[2*N+2][2*N+2];$/;" v +Z testsuite/libgomp.graphite/force-parallel-9.c /^int Z[2*N+2][2*N+2], B[2*N+2][2*N+2];$/;" v +_ACC_device_hwm openacc.h /^ _ACC_device_hwm,$/;" e enum:acc_device_t +_ACC_highest openacc.h /^ _ACC_highest = __INT_MAX__,$/;" e enum:acc_device_t +_ACC_neg openacc.h /^ _ACC_neg = -1$/;" e enum:acc_device_t +_GNU_SOURCE config/linux/affinity.c 29;" d file: +_GNU_SOURCE config/linux/futex.h 36;" d +_GNU_SOURCE config/linux/proc.c 30;" d file: +_GNU_SOURCE testsuite/libgomp.c/affinity-1.c 23;" d file: +_GNU_SOURCE testsuite/libgomp.c/icv-2.c 4;" d file: +_GNU_SOURCE testsuite/libgomp.c/lock-3.c 4;" d file: +_HSA_EXT_FINALIZE_H plugin/hsa_ext_finalize.h 35;" d +_LIBGOMP_CHECKING_ libgomp.h 41;" d +_LIBGOMP_OMP_LOCK_DEFINED libgomp.h 1069;" d +_OPENACC_H openacc.h 30;" d +_PRIORITY_QUEUE_H_ priority_queue.h 32;" d +_STATIC_TDG_CHECKING_ tdg.h 10;" d +_Tnum_timers testsuite/libgomp.oacc-c-c++-common/timer.h /^static int _Tnum_timers;$/;" v +_Tstart_events testsuite/libgomp.oacc-c-c++-common/timer.h /^static CUevent *_Tstart_events, *_Tstop_events;$/;" v +_Tstop_events testsuite/libgomp.oacc-c-c++-common/timer.h /^static CUevent *_Tstart_events, *_Tstop_events;$/;" v +_Tstream testsuite/libgomp.oacc-c-c++-common/timer.h /^static CUstream _Tstream;$/;" v +_XOPEN_SOURCE config/posix/lock.c 36;" d file: +__GOACC_NOTHROW openacc.h 42;" d +__GOACC_NOTHROW openacc.h 44;" d +__GOACC_NOTHROW openacc.h 46;" d +__nvptx_clocktick config/nvptx/time.c /^double __nvptx_clocktick = 0;$/;" v +a testsuite/libgomp.c++/declare_target-1.C /^ int a;$/;" m class:typeY file: +a testsuite/libgomp.c++/declare_target-1.C /^ int a;$/;" m struct:typeX file: +a testsuite/libgomp.c++/examples-4/declare_target-2.C /^ int a;$/;" m class:typeY file: +a testsuite/libgomp.c++/examples-4/declare_target-2.C /^ int a;$/;" m struct:typeX file: +a testsuite/libgomp.c++/linear-1.C /^int a[256];$/;" v +a testsuite/libgomp.c++/loop-3.C /^int a;$/;" v +a testsuite/libgomp.c++/loop-5.C /^int a[12];$/;" v +a testsuite/libgomp.c++/member-1.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-2.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-3.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-4.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-5.C /^struct A : public R, virtual public T { A () {} I a; void m1 (const I &, const I &); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-5.C /^struct B : public R, virtual public U { B () {} Q a; void m2 (const Q &, const Q &, const I &, const I &); };$/;" m struct:B file: +a testsuite/libgomp.c++/member-6.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/member-7.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +a testsuite/libgomp.c++/pr56217.C /^int a[6] = { 100, 101, 102, 103, 104, 105 };$/;" v +a testsuite/libgomp.c++/pr81130.C /^ int a;$/;" m struct:A file: +a testsuite/libgomp.c++/reduction-10.C /^ A a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-11.C /^ unsigned long long a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-12.C /^ A a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-5.C /^ unsigned long long a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-6.C /^ A a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-7.C /^ unsigned long long a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-8.C /^ A a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/reduction-9.C /^ unsigned long long a[9];$/;" m struct:S file: +a testsuite/libgomp.c++/simd-1.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-3.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-4.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-5.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-6.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-7.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-8.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd-9.C /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c++/simd14.C /^int a[1024];$/;" v +a testsuite/libgomp.c++/single-2.C /^ int a;$/;" m struct:X file: +a testsuite/libgomp.c++/target-10.C /^struct T { int a; union U b; int c; };$/;" m struct:T file: +a testsuite/libgomp.c++/target-11.C /^struct T { int a; int *b; int c; char (&d)[10]; };$/;" m struct:T file: +a testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +a testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +a testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +a testsuite/libgomp.c++/target-19.C /^struct S { char a[64]; int (&r)[2]; char b[64]; };$/;" m struct:S file: +a testsuite/libgomp.c++/target-20.C /^struct S { int a, b, c, d; };$/;" m struct:S file: +a testsuite/libgomp.c++/target-8.C /^struct S { int a; };$/;" m struct:S file: +a testsuite/libgomp.c++/task-1.C /^int a = 18;$/;" v +a testsuite/libgomp.c++/task-6.C /^int a = 18;$/;" v +a testsuite/libgomp.c++/tls-init1.C /^A a;$/;" v +a testsuite/libgomp.c++/udr-5.C /^ int a;$/;" m struct:S file: +a testsuite/libgomp.c++/udr-5.C /^ int a;$/;" m struct:T file: +a testsuite/libgomp.c++/udr-6.C /^ struct A { int a; A () : a (0) {} };$/;" m struct:N1::A file: +a testsuite/libgomp.c++/udr-6.C /^struct A { int a; A () : a (6) {} };$/;" m struct:A file: +a testsuite/libgomp.c/appendix-a/a.40.1.c /^ int a, b;$/;" m struct:__anon28 file: +a testsuite/libgomp.c/doacross-1.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8];$/;" v +a testsuite/libgomp.c/doacross-2.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +a testsuite/libgomp.c/doacross-3.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +a testsuite/libgomp.c/examples-4/simd-7.c /^int a[N], a_ref[N], b[N];$/;" v +a testsuite/libgomp.c/for-2.h /^int a[1500];$/;" v +a testsuite/libgomp.c/linear-1.c /^int a[256];$/;" v +a testsuite/libgomp.c/nonmonotonic-1.c /^int a[73];$/;" v +a testsuite/libgomp.c/omp-loop03.c /^int a;$/;" v +a testsuite/libgomp.c/omp-single-2.c /^ int a;$/;" m struct:X file: +a testsuite/libgomp.c/omp_orphan.c /^float a[VECLEN], b[VECLEN], sum;$/;" v +a testsuite/libgomp.c/ordered-5.c /^int a[1024], b = -1;$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-3.c /^unsigned int *a;$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-4.c /^unsigned int *a;$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.c/pr26943-2.c /^int a = 8, b = 12, c = 16, d = 20, j = 0;$/;" v +a testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +a testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +a testsuite/libgomp.c/pr32362-2.c /^int a = 2, b = 4;$/;" v +a testsuite/libgomp.c/pr32362-3.c /^int a = 2;$/;" v +a testsuite/libgomp.c/pr39591-3.c /^int err, a[40];$/;" v +a testsuite/libgomp.c/pr81875.c /^int a[N];$/;" v +a testsuite/libgomp.c/private-1.c /^int a = 18;$/;" v +a testsuite/libgomp.c/reduction-15.c /^int a[16], b[16], c[16], d[5][2];$/;" v +a testsuite/libgomp.c/simd-1.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-3.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-4.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-5.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-6.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-7.c /^int a[1024] __attribute__((aligned (32))) = { 1 };$/;" v +a testsuite/libgomp.c/simd-8.c /^int a[32][32] __attribute__((aligned (32))) = { { 1 } };$/;" v +a testsuite/libgomp.c/simd-9.c /^int a[32][32] __attribute__((aligned (32))) = { { 1 } };$/;" v +a testsuite/libgomp.c/target-21.c /^struct T { int a; union U b; int c; };$/;" m struct:T file: +a testsuite/libgomp.c/target-22.c /^struct T { int a; int *b; int c; };$/;" m struct:T file: +a testsuite/libgomp.c/target-26.c /^int a[4] = { 2, 3, 4, 5 }, *b;$/;" v +a testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +a testsuite/libgomp.c/target-31.c /^int a = 1, b = 2, c = 3, d = 4;$/;" v +a testsuite/libgomp.c/target-link-1.c /^int a = 1, b = 1;$/;" v +a testsuite/libgomp.c/task-1.c /^int a = 18;$/;" v +a testsuite/libgomp.c/taskloop-3.c /^int a[1024];$/;" v +a testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integer :: a,/;" k type:dl +a testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integer :: a,/;" k type:dl +a testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integer :: a,/;" k type:dl +a testsuite/libgomp.fortran/allocatable1.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable10.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable11.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable12.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable2.f90 /^ integer, sav/;" v +a testsuite/libgomp.fortran/allocatable3.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable4.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable5.f90 /^ integer, al/;" v program:pr42866 +a testsuite/libgomp.fortran/allocatable6.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable7.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/allocatable8.f90 /^ integer, sav/;" v +a testsuite/libgomp.fortran/allocatable9.f90 /^ integer, al/;" v +a testsuite/libgomp.fortran/associate1.f90 /^ real/;" v program:associate1 +a testsuite/libgomp.fortran/associate2.f90 /^ real/;" k type:dt +a testsuite/libgomp.fortran/associate2.f90 /^ type (dt) :: a(/;" v program:associate2 +a testsuite/libgomp.fortran/collapse1.f90 /^ integer :: i, j, k, a(/;" v program:collapse1 +a testsuite/libgomp.fortran/crayptr1.f90 /^ integer :: a,/;" v +a testsuite/libgomp.fortran/crayptr2.f90 /^ integer :: a,/;" v +a testsuite/libgomp.fortran/crayptr3.f90 /^ integer :: a,/;" v +a testsuite/libgomp.fortran/declare-simd-1.f90 /^ double precision :: a(/;" v +a testsuite/libgomp.fortran/do1.f90 /^ integer, dimension (128) :: a,/;" v +a testsuite/libgomp.fortran/do2.f90 /^ integer, dimension (128) :: a,/;" v +a testsuite/libgomp.fortran/doacross1.f90 /^ integer, sav/;" v +a testsuite/libgomp.fortran/doacross2.f90 /^ integer, sav/;" v +a testsuite/libgomp.fortran/doacross3.f90 /^ integer, sav/;" v +a testsuite/libgomp.fortran/examples-4/device-1.f90 /^ integer :: a,/;" v program:e_57_1 +a testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ double precision :: a(/;" v program:SIMD1 +a testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ double precision :: a(/;" v program:main +a testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ double precision :: a(/;" v program:SIMD3 +a testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ double precision, dimension(32, 32) :: a,/;" v program:SIMD5 +a testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ integer :: a(/;" v program:fibonacci +a testsuite/libgomp.fortran/nestedfn1.f90 /^ integer :: a,/;" v +a testsuite/libgomp.fortran/nestedfn4.f90 /^ integer :: a(/;" v program:foo +a testsuite/libgomp.fortran/omp_atomic1.f90 /^ integer (kind = 4) :: a$/;" v +a testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer (kind = 2) :: a,/;" v +a testsuite/libgomp.fortran/omp_atomic3.f90 /^ integer (kind = 4) :: a,/;" v +a testsuite/libgomp.fortran/omp_atomic4.f90 /^ integer (kind = 4) :: a,/;" v +a testsuite/libgomp.fortran/omp_atomic5.f90 /^ integer (kind = 4) :: a,/;" v +a testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.fortran/pointer1.f90 /^ integer, pointer :: a,/;" v +a testsuite/libgomp.fortran/pr27916-1.f90 /^ integer, dimension(:), al/;" v program:pr27916 +a testsuite/libgomp.fortran/pr27916-2.f90 /^ integer, dimension(:), al/;" v program:pr27916 +a testsuite/libgomp.fortran/pr32359.f90 /^ integer :: a /;" v +a testsuite/libgomp.fortran/pr35130.f90 /^ real/;" v program:pr35130 +a testsuite/libgomp.fortran/pr42162.f90 /^ integer :: k, a(/;" v program:pr42162 +a testsuite/libgomp.fortran/pr49792-1.f90 /^ real/;" v program:pr49792 +a testsuite/libgomp.fortran/pr49792-2.f90 /^ integer, al/;" v program:pr49792 +a testsuite/libgomp.fortran/pr65597.f90 /^ integer :: i, a(/;" v +a testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a,/;" v +a testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a,/;" v +a testsuite/libgomp.fortran/pr81304.f90 /^ real/;" v program:pr81304 +a testsuite/libgomp.fortran/pr81841.f90 /^ integer :: a$/;" v +a testsuite/libgomp.fortran/reduction6.f90 /^ integer, dimension (6, 6) :: a$/;" v +a testsuite/libgomp.fortran/simd1.f90 /^ integer :: i, j, k, l, r, s, a(/;" v +a testsuite/libgomp.fortran/simd2.f90 /^ integer :: a(/;" v +a testsuite/libgomp.fortran/simd3.f90 /^ integer :: a(/;" v +a testsuite/libgomp.fortran/simd4.f90 /^ integer :: a(/;" v +a testsuite/libgomp.fortran/tabs1.f90 /^subroutine a$/;" s +a testsuite/libgomp.fortran/tabs2.f /^ subroutine a$/;" s +a testsuite/libgomp.fortran/target2.f90 /^ integer :: a,/;" v +a testsuite/libgomp.fortran/target4.f90 /^ double precision :: a(/;" v +a testsuite/libgomp.fortran/target7.f90 /^ real/;" v +a testsuite/libgomp.fortran/target8.f90 /^ real/;" v +a testsuite/libgomp.fortran/udr12.f90 /^ integer :: a(/;" v +a testsuite/libgomp.fortran/udr13.f90 /^ integer :: a(/;" v +a testsuite/libgomp.fortran/udr14.f90 /^ type (dt), al/;" v +a testsuite/libgomp.fortran/udr15.f90 /^ integer, par/;" v module:udr15m1 +a testsuite/libgomp.fortran/udr8.f90 /^ integer, par/;" v module:udr8m1 +a testsuite/libgomp.fortran/udr9.f90 /^ integer, par/;" v module:udr9m1 +a testsuite/libgomp.fortran/workshare1.f90 /^ integer :: a /;" v +a testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a : 10;$/;" m struct:S1 file: +a testsuite/libgomp.oacc-c-c++-common/kernels-loop-collapse.c /^int a[N][N];$/;" v +a testsuite/libgomp.oacc-c-c++-common/kernels-reduction.c /^unsigned int a[n];$/;" v +a testsuite/libgomp.oacc-c-c++-common/vector-loop.c /^unsigned int a[N];$/;" v +a testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/clauses-1.f90 /^ real/;" v program:main +a testsuite/libgomp.oacc-fortran/collapse-1.f90 /^ integer :: i, j, k, a(/;" v program:collapse1 +a testsuite/libgomp.oacc-fortran/collapse-2.f90 /^ integer :: i, j, k, a(/;" v program:collapse2 +a testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(/;" v program:collapse3 +a testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ integer :: i, j, k, a(/;" v program:collapse4 +a testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: i, j, k, a(/;" v program:collapse5 +a testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: i, j, k, a(/;" v program:collapse6 +a testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ integer :: i, j, k, a(/;" v program:collapse7 +a testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: i, j, k, a(/;" v program:collapse8 +a testsuite/libgomp.oacc-fortran/combined-directives-1.f90 /^ real/;" v program:main +a testsuite/libgomp.oacc-fortran/data-1.f90 /^ real/;" v program:test +a testsuite/libgomp.oacc-fortran/data-2.f90 /^ real/;" v program:test +a testsuite/libgomp.oacc-fortran/data-3.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/data-4.f90 /^ real/;" v program:asyncwait +a testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer :: a(/;" v program:main +a testsuite/libgomp.oacc-fortran/declare-2.f90 /^ integer a$/;" v module:globalvars +a testsuite/libgomp.oacc-fortran/declare-3.f90 /^ real/;" v program:test +a testsuite/libgomp.oacc-fortran/declare-4.f90 /^ real/;" v program:test +a testsuite/libgomp.oacc-fortran/declare-5.f90 /^ real/;" v program:test +a testsuite/libgomp.oacc-fortran/default-1.f90 /^ real/;" v program:main +a testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ integer :: a,/;" v program:firstprivate +a testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^ integer i, a(/;" v program:main +a testsuite/libgomp.oacc-fortran/if-1.f90 /^ real/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ integer, dimension (0:n-1) :: a,/;" v program:main +a testsuite/libgomp.oacc-fortran/map-1.f90 /^ integer :: i, a(/;" v +a testsuite/libgomp.oacc-fortran/pointer-align-1.f90 /^ integer(kind=2) a(/;" v program:test +a testsuite/libgomp.oacc-fortran/pr68813.f90 /^ integer, dimension(n,n) :: a$/;" v program:foo +a testsuite/libgomp.oacc-fortran/routine-1.f90 /^ integer :: a(/;" v +a testsuite/libgomp.oacc-fortran/routine-2.f90 /^ integer :: a(/;" v +a testsuite/libgomp.oacc-fortran/routine-3.f90 /^ integer :: a(/;" v +a testsuite/libgomp.oacc-fortran/routine-4.f90 /^ integer :: a(/;" v +a testsuite/libgomp.oacc-fortran/routine-7.f90 /^ integer :: a(/;" v program:main +a testsuite/libgomp.oacc-fortran/routine-9.f90 /^ integer :: a(/;" v program:main +a testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^ integer :: i, a(/;" v program:subarrays +a testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ integer :: i, a(/;" v program:subarrays +a testsuite/libgomp.oacc-fortran/update-1.f90 /^ real/;" v program:update +a1 testsuite/libgomp.c/atomic-10.c /^float a1, a2, a3, a4;$/;" v +a1 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1,/;" v +a1 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1,/;" v +a1 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a1 : 10;$/;" m struct:S2 file: +a1 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a1 : 10;$/;" m struct:S3 file: +a1 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a1 : 10;$/;" m struct:S4 file: +a1 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a1 : 31;$/;" m struct:S5 file: +a1 testsuite/libgomp.oacc-fortran/pset-1.f90 /^ integer, allocatable :: a1(/;" v program:test +a1 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1, h2, s1, s2, a1,/;" v program:reduction +a10 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a10 : 9;$/;" m struct:S4 file: +a10 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a10 : 9;$/;" m struct:S5 file: +a10 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a10 : 10;$/;" m struct:S2 file: +a10 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a10 : 9;$/;" m struct:S3 file: +a16 testsuite/libgomp.c/appendix-a/a.16.1.c /^a16 (float *x, float *y, int *index, int n)$/;" f +a2 testsuite/libgomp.c/atomic-10.c /^float a1, a2, a3, a4;$/;" v +a2 testsuite/libgomp.fortran/omp_atomic3.f90 /^ integer (kind = 4) :: a, a2$/;" v +a2 testsuite/libgomp.fortran/omp_atomic4.f90 /^ integer (kind = 4) :: a, a2$/;" v +a2 testsuite/libgomp.fortran/omp_atomic5.f90 /^ integer (kind = 4) :: a, a2$/;" v +a2 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2,/;" v +a2 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2,/;" v +a2 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a2 : 9;$/;" m struct:S4 file: +a2 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a2 : 9;$/;" m struct:S5 file: +a2 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a2 : 10;$/;" m struct:S2 file: +a2 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a2 : 9;$/;" m struct:S3 file: +a2 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1, h2, s1, s2, a1, a2$/;" v program:reduction +a21 testsuite/libgomp.c/appendix-a/a.21.1.c /^a21 (int lb, int ub, int stride)$/;" f +a3 testsuite/libgomp.c++/reduction-10.C /^A a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-11.C /^int a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-12.C /^A a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-5.C /^int a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-6.C /^A a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-7.C /^int a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-8.C /^A a3[4][3][2];$/;" v +a3 testsuite/libgomp.c++/reduction-9.C /^int a3[4][3][2];$/;" v +a3 testsuite/libgomp.c/atomic-10.c /^float a1, a2, a3, a4;$/;" v +a3 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a3 : 10;$/;" m struct:S2 file: +a3 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a3 : 17;$/;" m struct:S5 file: +a3 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a3 : 8;$/;" m struct:S3 file: +a3 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a3 : 8;$/;" m struct:S4 file: +a36 testsuite/libgomp.c/appendix-a/a.36.1.c /^a36 (float *x, int npoints)$/;" f +a4 testsuite/libgomp.c/atomic-10.c /^float a1, a2, a3, a4;$/;" v +a4 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a4 : 7;$/;" m struct:S4 file: +a4 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a4 : 7;$/;" m struct:S5 file: +a4 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a4 : 10;$/;" m struct:S2 file: +a4 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a4 : 7;$/;" m struct:S3 file: +a40 testsuite/libgomp.c/appendix-a/a.40.1.c /^a40 (pair * p)$/;" f +a5 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a5 : 10;$/;" m struct:S2 file: +a5 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a5 : 6;$/;" m struct:S3 file: +a5 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a5 : 6;$/;" m struct:S4 file: +a5 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a5 : 6;$/;" m struct:S5 file: +a6 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a6 : 5;$/;" m struct:S4 file: +a6 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a6 : 5;$/;" m struct:S5 file: +a6 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a6 : 10;$/;" m struct:S2 file: +a6 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a6 : 5;$/;" m struct:S3 file: +a7 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a7 : 10;$/;" m struct:S2 file: +a7 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a7 : 6;$/;" m struct:S3 file: +a7 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a7 : 6;$/;" m struct:S4 file: +a7 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned long a7 : 55;$/;" m struct:S5 file: +a8 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a8 : 7;$/;" m struct:S4 file: +a8 testsuite/libgomp.hsa.c/bitfield-1.c /^ int a8 : 7;$/;" m struct:S5 file: +a8 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a8 : 10;$/;" m struct:S2 file: +a8 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a8 : 7;$/;" m struct:S3 file: +a9 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a9 : 10;$/;" m struct:S2 file: +a9 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a9 : 8;$/;" m struct:S3 file: +a9 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a9 : 8;$/;" m struct:S4 file: +a9 testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned a9 : 8;$/;" m struct:S5 file: +a_3d_c testsuite/libgomp.oacc-fortran/lib-10.f90 /^ complex a_3d_c(/;" v program:main +a_3d_c testsuite/libgomp.oacc-fortran/lib-8.f90 /^ complex a_3d_c(/;" v program:main +a_3d_i testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer, target :: a_3d_i(/;" v program:main +a_3d_i testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer, target :: a_3d_i(/;" v program:main +a_3d_r testsuite/libgomp.oacc-fortran/lib-10.f90 /^ real a_3d_r(/;" v program:main +a_3d_r testsuite/libgomp.oacc-fortran/lib-8.f90 /^ real a_3d_r(/;" v program:main +a_ref testsuite/libgomp.c/examples-4/simd-7.c /^int a[N], a_ref[N], b[N];$/;" v +a_ref testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ double precision :: a(128), a_ref(/;" v program:SIMD1 +a_ref testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ double precision :: a(N), b(N), a_ref(/;" v program:main +a_ref testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ integer :: a_ref(/;" v program:fibonacci +ac testsuite/libgomp.c++/ctor-13.C /^ static int ic, dc, xc, ac, cc;$/;" m struct:B file: +ac testsuite/libgomp.c++/ctor-13.C /^int B::ac;$/;" m class:B file: +ac_fn_c_check_func configure /^ac_fn_c_check_func ()$/;" f +ac_fn_c_check_header_compile configure /^ac_fn_c_check_header_compile ()$/;" f +ac_fn_c_check_header_mongrel configure /^ac_fn_c_check_header_mongrel ()$/;" f +ac_fn_c_check_type configure /^ac_fn_c_check_type ()$/;" f +ac_fn_c_compute_int configure /^ac_fn_c_compute_int ()$/;" f +ac_fn_c_try_compile configure /^ac_fn_c_try_compile ()$/;" f +ac_fn_c_try_cpp configure /^ac_fn_c_try_cpp ()$/;" f +ac_fn_c_try_link configure /^ac_fn_c_try_link ()$/;" f +ac_fn_c_try_run configure /^ac_fn_c_try_run ()$/;" f +ac_fn_fc_try_compile configure /^ac_fn_fc_try_compile ()$/;" f +ac_fn_fc_try_link configure /^ac_fn_fc_try_link ()$/;" f +acc_async_noval openacc.f90 /^ integer (acc_handle_kind), parameter :: acc_async_noval /;" v module:openacc_kinds +acc_async_noval openacc.h /^ acc_async_noval = -1,$/;" e enum:acc_async_t +acc_async_sync openacc.f90 /^ integer (acc_handle_kind), parameter :: acc_async_sync /;" v module:openacc_kinds +acc_async_sync openacc.h /^ acc_async_sync = -2$/;" e enum:acc_async_t +acc_async_t openacc.h /^typedef enum acc_async_t {$/;" g +acc_async_t openacc.h /^} acc_async_t;$/;" t typeref:enum:acc_async_t +acc_async_test oacc-async.c /^acc_async_test (int async)$/;" f +acc_async_test_all oacc-async.c /^acc_async_test_all (void)$/;" f +acc_async_test_all_h openacc.f90 /^function acc_async_test_all_h /;" f +acc_async_test_h openacc.f90 /^function acc_async_test_h /;" f +acc_copyin oacc-mem.c /^acc_copyin (void *h, size_t s)$/;" f +acc_copyin_32_h openacc.f90 /^subroutine acc_copyin_32_h /;" s +acc_copyin_64_h openacc.f90 /^subroutine acc_copyin_64_h /;" s +acc_copyin_array_h openacc.f90 /^subroutine acc_copyin_array_h /;" s +acc_copyout oacc-mem.c /^acc_copyout (void *h, size_t s)$/;" f +acc_copyout_32_h openacc.f90 /^subroutine acc_copyout_32_h /;" s +acc_copyout_64_h openacc.f90 /^subroutine acc_copyout_64_h /;" s +acc_copyout_array_h openacc.f90 /^subroutine acc_copyout_array_h /;" s +acc_create oacc-mem.c /^acc_create (void *h, size_t s)$/;" f +acc_create_32_h openacc.f90 /^subroutine acc_create_32_h /;" s +acc_create_64_h openacc.f90 /^subroutine acc_create_64_h /;" s +acc_create_array_h openacc.f90 /^subroutine acc_create_array_h /;" s +acc_delete oacc-mem.c /^acc_delete (void *h , size_t s)$/;" f +acc_delete_32_h openacc.f90 /^subroutine acc_delete_32_h /;" s +acc_delete_64_h openacc.f90 /^subroutine acc_delete_64_h /;" s +acc_delete_array_h openacc.f90 /^subroutine acc_delete_array_h /;" s +acc_dev_num_out_of_range oacc-init.c /^acc_dev_num_out_of_range (acc_device_t d, int ord, int ndevs)$/;" f file: +acc_device_default config/nvptx/openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_default /;" v module:openacc_kinds +acc_device_default openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_default /;" v module:openacc_kinds +acc_device_default openacc.h /^ acc_device_default = 1,$/;" e enum:acc_device_t +acc_device_host config/nvptx/openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_host /;" v module:openacc_kinds +acc_device_host openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_host /;" v module:openacc_kinds +acc_device_host openacc.h /^ acc_device_host = 2,$/;" e enum:acc_device_t +acc_device_kind config/nvptx/openacc.f90 /^ integer, parameter :: acc_device_kind /;" v module:openacc_kinds +acc_device_kind openacc.f90 /^ integer, parameter :: acc_device_kind /;" v module:openacc_kinds +acc_device_lock oacc-init.c /^static gomp_mutex_t acc_device_lock;$/;" v file: +acc_device_none config/nvptx/openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_none /;" v module:openacc_kinds +acc_device_none openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_none /;" v module:openacc_kinds +acc_device_none openacc.h /^ acc_device_none = 0,$/;" e enum:acc_device_t +acc_device_not_host config/nvptx/openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_not_host /;" v module:openacc_kinds +acc_device_not_host openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_not_host /;" v module:openacc_kinds +acc_device_not_host openacc.h /^ acc_device_not_host = 4,$/;" e enum:acc_device_t +acc_device_nvidia config/nvptx/openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_nvidia /;" v module:openacc_kinds +acc_device_nvidia openacc.f90 /^ integer (acc_device_kind), parameter :: acc_device_nvidia /;" v module:openacc_kinds +acc_device_nvidia openacc.h /^ acc_device_nvidia = 5,$/;" e enum:acc_device_t +acc_device_t openacc.h /^typedef enum acc_device_t {$/;" g +acc_device_t openacc.h /^} acc_device_t;$/;" t typeref:enum:acc_device_t +acc_device_type oacc-int.h /^acc_device_type (enum offload_target_type type)$/;" f +acc_deviceptr oacc-mem.c /^acc_deviceptr (void *h)$/;" f +acc_dispatch_t libgomp.h /^typedef struct acc_dispatch_t$/;" s +acc_dispatch_t libgomp.h /^} acc_dispatch_t;$/;" t typeref:struct:acc_dispatch_t +acc_free oacc-mem.c /^acc_free (void *d)$/;" f +acc_get_cuda_stream oacc-cuda.c /^acc_get_cuda_stream (int async)$/;" f +acc_get_current_cuda_context oacc-cuda.c /^acc_get_current_cuda_context (void)$/;" f +acc_get_current_cuda_device oacc-cuda.c /^acc_get_current_cuda_device (void)$/;" f +acc_get_device_num_h openacc.f90 /^function acc_get_device_num_h /;" f +acc_get_device_type_h openacc.f90 /^function acc_get_device_type_h /;" f +acc_get_num_devices_h openacc.f90 /^function acc_get_num_devices_h /;" f +acc_handle_kind openacc.f90 /^ integer, parameter :: acc_handle_kind /;" v module:openacc_kinds +acc_hostptr oacc-mem.c /^acc_hostptr (void *d)$/;" f +acc_init oacc-init.c /^acc_init (acc_device_t d)$/;" f +acc_init_1 oacc-init.c /^acc_init_1 (acc_device_t d)$/;" f file: +acc_init_h openacc.f90 /^subroutine acc_init_h /;" s +acc_is_present oacc-mem.c /^acc_is_present (void *h, size_t s)$/;" f +acc_is_present_32_h openacc.f90 /^function acc_is_present_32_h /;" f +acc_is_present_64_h openacc.f90 /^function acc_is_present_64_h /;" f +acc_is_present_array_h openacc.f90 /^function acc_is_present_array_h /;" f +acc_malloc oacc-mem.c /^acc_malloc (size_t s)$/;" f +acc_map_data oacc-mem.c /^acc_map_data (void *h, void *d, size_t s)$/;" f +acc_memcpy_from_device oacc-mem.c /^acc_memcpy_from_device (void *h, void *d, size_t s)$/;" f +acc_memcpy_to_device oacc-mem.c /^acc_memcpy_to_device (void *d, void *h, size_t s)$/;" f +acc_on_device config/nvptx/oacc-init.c /^acc_on_device (acc_device_t dev)$/;" f +acc_on_device_h config/nvptx/openacc.f90 /^function acc_on_device_h /;" f +acc_on_device_h openacc.f90 /^function acc_on_device_h /;" f +acc_pcopyin openacc.h 111;" d +acc_pcreate openacc.h 110;" d +acc_present_or_copyin oacc-mem.c /^acc_present_or_copyin (void *h, size_t s)$/;" f +acc_present_or_copyin_32_h openacc.f90 /^subroutine acc_present_or_copyin_32_h /;" s +acc_present_or_copyin_64_h openacc.f90 /^subroutine acc_present_or_copyin_64_h /;" s +acc_present_or_copyin_array_h openacc.f90 /^subroutine acc_present_or_copyin_array_h /;" s +acc_present_or_create oacc-mem.c /^acc_present_or_create (void *h, size_t s)$/;" f +acc_present_or_create_32_h openacc.f90 /^subroutine acc_present_or_create_32_h /;" s +acc_present_or_create_64_h openacc.f90 /^subroutine acc_present_or_create_64_h /;" s +acc_present_or_create_array_h openacc.f90 /^subroutine acc_present_or_create_array_h /;" s +acc_set_cuda_stream oacc-cuda.c /^acc_set_cuda_stream (int async, void *stream)$/;" f +acc_set_device_num_h openacc.f90 /^subroutine acc_set_device_num_h /;" s +acc_set_device_type_h openacc.f90 /^subroutine acc_set_device_type_h /;" s +acc_shutdown_1 oacc-init.c /^acc_shutdown_1 (acc_device_t d)$/;" f file: +acc_shutdown_h openacc.f90 /^subroutine acc_shutdown_h /;" s +acc_unmap_data oacc-mem.c /^acc_unmap_data (void *h)$/;" f +acc_update_device oacc-mem.c /^acc_update_device (void *h, size_t s)$/;" f +acc_update_device_32_h openacc.f90 /^subroutine acc_update_device_32_h /;" s +acc_update_device_64_h openacc.f90 /^subroutine acc_update_device_64_h /;" s +acc_update_device_array_h openacc.f90 /^subroutine acc_update_device_array_h /;" s +acc_update_self oacc-mem.c /^acc_update_self (void *h, size_t s)$/;" f +acc_update_self_32_h openacc.f90 /^subroutine acc_update_self_32_h /;" s +acc_update_self_64_h openacc.f90 /^subroutine acc_update_self_64_h /;" s +acc_update_self_array_h openacc.f90 /^subroutine acc_update_self_array_h /;" s +acc_wait oacc-async.c /^acc_wait (int async)$/;" f +acc_wait_all oacc-async.c /^acc_wait_all (void)$/;" f +acc_wait_all_async oacc-async.c /^acc_wait_all_async (int async)$/;" f +acc_wait_all_async_h openacc.f90 /^subroutine acc_wait_all_async_h /;" s +acc_wait_all_h openacc.f90 /^subroutine acc_wait_all_h /;" s +acc_wait_async oacc-async.c /^acc_wait_async (int async1, int async2)$/;" f +acc_wait_async_h openacc.f90 /^subroutine acc_wait_async_h /;" s +acc_wait_h openacc.f90 /^subroutine acc_wait_h /;" s +accum testsuite/libgomp.c/examples-4/declare_target-4.c /^float accum (int k)$/;" f +accum testsuite/libgomp.c/examples-4/declare_target-5.c /^float accum ()$/;" f +accum testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ real :: accum,/;" v program:e_53_4 +accum testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^real function accum /;" f +accum testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ real :: accum,/;" v program:e_53_5 +accum testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^real function accum /;" f +accum_ref testsuite/libgomp.c/examples-4/declare_target-4.c /^float accum_ref (int k)$/;" f +accum_ref testsuite/libgomp.c/examples-4/declare_target-5.c /^float accum_ref ()$/;" f +accum_ref testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ real :: accum, accum_ref$/;" v program:e_53_4 +accum_ref testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^real function accum_ref /;" f +accum_ref testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ real :: accum, accum_ref,/;" v program:e_53_5 +accum_ref testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^real function accum_ref /;" f +active_level libgomp.h /^ unsigned active_level;$/;" m struct:gomp_team_state +active_streams plugin/plugin-nvptx.c /^ struct ptx_stream *active_streams;$/;" m struct:ptx_device typeref:struct:ptx_device::ptx_stream file: +add testsuite/libgomp.c++/reduction-10.C /^add (T &x, T &y)$/;" f +add testsuite/libgomp.c++/reduction-12.C /^add (T &x, T &y)$/;" f +add testsuite/libgomp.c++/reduction-6.C /^add (T &x, T &y)$/;" f +add testsuite/libgomp.c++/reduction-8.C /^add (T &x, T &y)$/;" f +add testsuite/libgomp.c/reduction-10.c /^add (struct B *x, struct B *y)$/;" f +add testsuite/libgomp.c/reduction-12.c /^add (struct B *x, struct B *y)$/;" f +add testsuite/libgomp.c/reduction-14.c /^add (struct B *x, struct B *y)$/;" f +add testsuite/libgomp.c/reduction-8.c /^add (struct B *x, struct B *y)$/;" f +add1 testsuite/libgomp.c/examples-4/simd-2.c /^double add1(double a, double b, double fact)$/;" f +add1 testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ function add1(/;" f module:SIMD2_mod +add2 testsuite/libgomp.c/examples-4/simd-2.c /^double add2(double *a, double *b, int i, double fact)$/;" f +add2 testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ function add2(/;" f module:SIMD2_mod +add3 testsuite/libgomp.c/examples-4/simd-2.c /^double add3(double *a, double *b, double fact)$/;" f +add_module_to_agent plugin/plugin-hsa.c /^add_module_to_agent (struct agent_info *agent, struct module_info *module)$/;" f file: +add_shared_library plugin/plugin-hsa.c /^add_shared_library (const char *file_name, struct agent_info *agent)$/;" f file: +addme testsuite/libgomp.fortran/udr10.f90 /^ type(dt) function addme /;" f module:udr10m +addr libgomp.h /^ void *addr;$/;" m struct:gomp_task_depend_entry +addr plugin/plugin-nvptx.c /^ void *addr;$/;" m struct:ptx_event file: +addr_pair libgomp-plugin.h /^struct addr_pair$/;" s +address plugin/plugin-hsa.c /^ void *address;$/;" m struct:global_var_info file: +address_mode plugin/hsa_ext_finalize.h /^ hsa_ext_sampler_addressing_mode_t address_mode;$/;" m struct:hsa_ext_sampler_descriptor_s +agent plugin/plugin-hsa.c /^ struct agent_info *agent;$/;" m struct:kernel_info typeref:struct:kernel_info::agent_info file: +agent_count plugin/plugin-hsa.c /^ int agent_count;$/;" m struct:hsa_context_info file: +agent_info plugin/plugin-hsa.c /^struct agent_info$/;" s file: +agents plugin/plugin-hsa.c /^ struct agent_info *agents;$/;" m struct:hsa_context_info typeref:struct:hsa_context_info::agent_info file: +alignment plugin/hsa_ext_finalize.h /^ size_t alignment;$/;" m struct:hsa_ext_image_data_info_s +alloc_dl testsuite/libgomp.fortran/alloc-comp-1.f90 /^ subroutine alloc_dl /;" s module:m +alloc_dl testsuite/libgomp.fortran/alloc-comp-2.f90 /^ subroutine alloc_dl /;" s module:m +alloc_dl testsuite/libgomp.fortran/alloc-comp-3.f90 /^ subroutine alloc_dl /;" s module:m +alloc_dt testsuite/libgomp.fortran/alloc-comp-1.f90 /^ subroutine alloc_dt /;" s module:m +alloc_dt testsuite/libgomp.fortran/alloc-comp-2.f90 /^ subroutine alloc_dt /;" s module:m +alloc_dt testsuite/libgomp.fortran/alloc-comp-3.f90 /^ subroutine alloc_dt /;" s module:m +alloc_func libgomp.h /^ __typeof (GOMP_OFFLOAD_alloc) *alloc_func;$/;" m struct:gomp_device_descr +alloc_work_share work.c /^alloc_work_share (struct gomp_team *team)$/;" f file: +allocate_thread_pool_reservoir config/rtems/proc.c /^allocate_thread_pool_reservoir (unsigned long count, unsigned long priority,$/;" f file: +allocate_thread_pool_reservoirs config/rtems/proc.c /^allocate_thread_pool_reservoirs (void)$/;" f file: +allocated libgomp.h /^ size_t allocated;$/;" m struct:gomp_dependers_vec +alpha testsuite/libgomp.fortran/jacobi.f /^ double precision tol,relax,alpha /;" v program:main +always_copy_from libgomp.h /^ bool always_copy_from;$/;" m struct:target_var_desc +antidep testsuite/libgomp.c/depend-1.c /^antidep (void)$/;" f +antidep testsuite/libgomp.fortran/depend-1.f90 /^ subroutine antidep$/;" s +antidep2 testsuite/libgomp.c/depend-1.c /^antidep2 (void)$/;" f +antidep2 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine antidep2$/;" s +antidep3 testsuite/libgomp.c/depend-1.c /^antidep3 (void)$/;" f +antidep3 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine antidep3$/;" s +argc testsuite/libgomp.oacc-fortran/abort-2.f90 /^ integer :: argc$/;" v program:main +args libgomp.h /^ void **args;$/;" m struct:gomp_target_task +args plugin/plugin-hsa.c /^ void **args;$/;" m struct:async_run_info file: +arr plugin/plugin-nvptx.c /^ struct ptx_stream **arr;$/;" m struct:ptx_device::__anon9 typeref:struct:ptx_device::__anon9::ptx_stream file: +arr testsuite/libgomp.c++/loop-12.C /^int arr[6 * 5];$/;" v +arr testsuite/libgomp.c++/loop-9.C /^int arr[6 * 5];$/;" v +arr testsuite/libgomp.c++/simd-2.C /^__UINTPTR_TYPE__ arr[1027];$/;" v +arr testsuite/libgomp.c/loop-12.c /^int arr[6 * 5];$/;" v +arr testsuite/libgomp.c/loop-6.c /^int arr[6 * 5];$/;" v +arr testsuite/libgomp.c/simd-2.c /^__UINTPTR_TYPE__ arr[1027];$/;" v +arr testsuite/libgomp.c/sort-1.c /^ struct int_pair arr[STACK_SIZE];$/;" m struct:int_pair_stack typeref:struct:int_pair_stack::int_pair file: +arr testsuite/libgomp.fortran/examples-4/simd-8.f90 /^ real :: pri, arr(/;" v program:simd_8f +arr testsuite/libgomp.oacc-fortran/host_data-1.f90 /^ integer, target :: i, arr(/;" v program:test +arr testsuite/libgomp.oacc-fortran/pr70643.f90 /^ real(kind=8), dimension(1:10,1:10) :: arr$/;" v program:main +arr testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ integer :: i, j, vsum, cs, arr(/;" v program:reduction +array libgomp.h /^ splay_tree_node array;$/;" m struct:target_mem_desc +array libgomp.h /^ unsigned char *array;$/;" m struct:gomp_doacross_work_share +array testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^ integer :: array(/;" v program:main +array testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer, dimension (n) :: array$/;" v program:reduction_1 +array testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real, dimension (n) :: array$/;" v program:reduction_2 +array testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision, dimension (n) :: array$/;" v program:reduction_3 +array testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ complex, dimension (n) :: array$/;" v program:reduction_4 +array_size plugin/hsa_ext_finalize.h /^ size_t array_size;$/;" m struct:hsa_ext_image_descriptor_s +arrived config/posix/bar.h /^ unsigned arrived;$/;" m struct:__anon35 +as_fn_append configure /^ as_fn_append ()$/;" f +as_fn_arith configure /^ as_fn_arith ()$/;" f +as_fn_error configure /^as_fn_error ()$/;" f +as_fn_executable_p configure /^as_fn_executable_p ()$/;" f +as_fn_exit configure /^as_fn_exit ()$/;" f +as_fn_failure configure /^as_fn_failure () { as_fn_return 1; }$/;" f +as_fn_mkdir_p configure /^as_fn_mkdir_p ()$/;" f +as_fn_ret_failure configure /^as_fn_ret_failure () { return 1; }$/;" f +as_fn_ret_success configure /^as_fn_ret_success () { return 0; }$/;" f +as_fn_set_status configure /^as_fn_set_status ()$/;" f +as_fn_success configure /^as_fn_success () { as_fn_return 0; }$/;" f +as_fn_unset configure /^as_fn_unset ()$/;" f +assign_agent_ids plugin/plugin-hsa.c /^assign_agent_ids (hsa_agent_t agent, void *data)$/;" f file: +assignops testsuite/libgomp.c++/ctor-12.C /^ static int ctors, dtors, copyctors, assignops;$/;" m struct:A file: +assignops testsuite/libgomp.c++/ctor-12.C /^int A::assignops;$/;" m class:A file: +associate1 testsuite/libgomp.fortran/associate1.f90 /^program associate1$/;" p +associate2 testsuite/libgomp.fortran/associate2.f90 /^program associate2$/;" p +async plugin/plugin-nvptx.c /^ int async;$/;" m struct:map file: +async_data plugin/plugin-hsa.c /^ void *async_data;$/;" m struct:async_run_info file: +async_run_func libgomp.h /^ __typeof (GOMP_OFFLOAD_async_run) *async_run_func;$/;" m struct:gomp_device_descr +async_run_info plugin/plugin-hsa.c /^struct async_run_info$/;" s file: +async_set_async_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_set_async) *async_set_async_func;$/;" m struct:acc_dispatch_t +async_streams plugin/plugin-nvptx.c /^ } async_streams;$/;" m struct:ptx_device typeref:struct:ptx_device::__anon9 file: +async_sum testsuite/libgomp.oacc-c++/template-reduction.C /^async_sum (T array[])$/;" f +async_sum testsuite/libgomp.oacc-c++/template-reduction.C /^async_sum (int c)$/;" f +async_sum testsuite/libgomp.oacc-c-c++-common/reduction-8.c /^async_sum (int c)$/;" f +async_test_all_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_test_all) *async_test_all_func;$/;" m struct:acc_dispatch_t +async_test_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_test) *async_test_func;$/;" m struct:acc_dispatch_t +async_wait_all_async_func libgomp.h /^ *async_wait_all_async_func;$/;" m struct:acc_dispatch_t +async_wait_all_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_wait_all) *async_wait_all_func;$/;" m struct:acc_dispatch_t +async_wait_async_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_wait_async) *async_wait_async_func;$/;" m struct:acc_dispatch_t +async_wait_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_async_wait) *async_wait_func;$/;" m struct:acc_dispatch_t +asyncwait testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^program asyncwait$/;" p +asyncwait testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^program asyncwait$/;" p +asyncwait testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^program asyncwait$/;" p +asyncwait testsuite/libgomp.oacc-fortran/data-3.f90 /^program asyncwait$/;" p +asyncwait testsuite/libgomp.oacc-fortran/data-4-2.f90 /^program asyncwait$/;" p +asyncwait testsuite/libgomp.oacc-fortran/data-4.f90 /^program asyncwait$/;" p +atomic_add testsuite/libgomp.fortran/pr34020.f90 /^ subroutine atomic_add(/;" s +atomic_lock atomic.c /^static gomp_mutex_t atomic_lock;$/;" v file: +atomic_write_barrier config/linux/tile/futex.h /^atomic_write_barrier (void)$/;" f +attr testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int attr[13];$/;" m struct:__anon25 file: +attr testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x, y, z, attr(/;" k type:vec3 +attribute_hidden libgomp.h 1122;" d +attribute_hidden libgomp.h 1124;" d +available config/rtems/pool.h /^ gomp_sem_t available;$/;" m struct:gomp_thread_pool_reservoir +awaited config/linux/bar.h /^ unsigned awaited __attribute__((aligned (64)));$/;" m struct:__anon42 +awaited config/nvptx/bar.h /^ unsigned awaited;$/;" m struct:__anon39 +awaited config/rtems/bar.h /^ unsigned awaited __attribute__((aligned (64)));$/;" m struct:__anon43 +awaited_final config/linux/bar.h /^ unsigned awaited_final;$/;" m struct:__anon42 +awaited_final config/nvptx/bar.h /^ unsigned awaited_final;$/;" m struct:__anon39 +awaited_final config/rtems/bar.h /^ unsigned awaited_final;$/;" m struct:__anon43 +b testsuite/libgomp.c++/collapse-2.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-1.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-2.C /^ T b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-3.C /^ const_iterator b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-4.C /^ iterator b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-5.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/for-8.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/member-1.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/member-2.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/member-3.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/member-4.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/member-6.C /^struct A : public R, virtual public T { A () : b(c) {} int a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/member-7.C /^struct A : public R, virtual public T { A () : b(c), a(e) {} Q a; int &b; void m1 (); };$/;" m struct:A file: +b testsuite/libgomp.c++/pr81130.C /^ A b;$/;" m struct:B file: +b testsuite/libgomp.c++/reduction-10.C /^ short b[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-11.C /^ short (&b)[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-12.C /^ short b[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-5.C /^ short (&b)[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-6.C /^ short b[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-7.C /^ short (&b)[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-8.C /^ short b[5];$/;" m struct:S file: +b testsuite/libgomp.c++/reduction-9.C /^ short (&b)[5];$/;" m struct:S file: +b testsuite/libgomp.c++/shared-1.C /^ float b[10];$/;" m struct:X file: +b testsuite/libgomp.c++/simd-1.C /^int b[1024] __attribute__((aligned (32))) = { 1 };$/;" v +b testsuite/libgomp.c++/simd-3.C /^int b[1024] __attribute__((aligned (32))) = { 1 };$/;" v +b testsuite/libgomp.c++/simd14.C /^short b[2048];$/;" v +b testsuite/libgomp.c++/single-2.C /^ char b;$/;" m struct:X file: +b testsuite/libgomp.c++/target-10.C /^struct T { int a; union U b; int c; };$/;" m struct:T typeref:union:T::U file: +b testsuite/libgomp.c++/target-11.C /^struct T { int a; int *b; int c; char (&d)[10]; };$/;" m struct:T file: +b testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +b testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +b testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +b testsuite/libgomp.c++/target-19.C /^struct S { char a[64]; int (&r)[2]; char b[64]; };$/;" m struct:S file: +b testsuite/libgomp.c++/target-2.C /^double b[1024];$/;" v +b testsuite/libgomp.c++/target-20.C /^struct S { int a, b, c, d; };$/;" m struct:S file: +b testsuite/libgomp.c++/task-3.C /^A b;$/;" v +b testsuite/libgomp.c++/task-5.C /^A b;$/;" v +b testsuite/libgomp.c++/taskloop-6.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/taskloop-7.C /^ const_iterator b, e;$/;" m class:J file: +b testsuite/libgomp.c++/taskloop-8.C /^ iterator b, e;$/;" m class:J file: +b testsuite/libgomp.c++/taskloop-9.C /^ I b, e;$/;" m class:J file: +b testsuite/libgomp.c++/udr-6.C /^struct B { int b; B () : b (5) {} };$/;" m struct:B file: +b testsuite/libgomp.c/appendix-a/a.40.1.c /^ int a, b;$/;" m struct:__anon28 file: +b testsuite/libgomp.c/doacross-1.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8];$/;" v +b testsuite/libgomp.c/doacross-2.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +b testsuite/libgomp.c/doacross-3.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +b testsuite/libgomp.c/examples-4/simd-7.c /^int a[N], a_ref[N], b[N];$/;" v +b testsuite/libgomp.c/for-2.h /^float b[10][15][10];$/;" v +b testsuite/libgomp.c/omp-single-2.c /^ char b;$/;" m struct:X file: +b testsuite/libgomp.c/omp_orphan.c /^float a[VECLEN], b[VECLEN], sum;$/;" v +b testsuite/libgomp.c/ordered-5.c /^int a[1024], b = -1;$/;" v +b testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.c/pr26943-2.c /^int a = 8, b = 12, c = 16, d = 20, j = 0;$/;" v +b testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +b testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +b testsuite/libgomp.c/pr32362-2.c /^int a = 2, b = 4;$/;" v +b testsuite/libgomp.c/reduction-15.c /^int a[16], b[16], c[16], d[5][2];$/;" v +b testsuite/libgomp.c/shared-1.c /^ float b[10];$/;" m struct:X file: +b testsuite/libgomp.c/simd-1.c /^int b[1024] __attribute__((aligned (32))) = { 1 };$/;" v +b testsuite/libgomp.c/simd-3.c /^int b[1024] __attribute__((aligned (32))) = { 1 };$/;" v +b testsuite/libgomp.c/simd-7.c /^int b[1024] __attribute__((aligned (32))) = { 1 };$/;" v +b testsuite/libgomp.c/target-21.c /^struct T { int a; union U b; int c; };$/;" m struct:T typeref:union:T::U file: +b testsuite/libgomp.c/target-22.c /^struct T { int a; int *b; int c; };$/;" m struct:T file: +b testsuite/libgomp.c/target-26.c /^int a[4] = { 2, 3, 4, 5 }, *b;$/;" v +b testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +b testsuite/libgomp.c/target-31.c /^int a = 1, b = 2, c = 3, d = 4;$/;" v +b testsuite/libgomp.c/target-link-1.c /^int a = 1, b = 1;$/;" v +b testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integer :: a, b$/;" k type:dl +b testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integer :: a, b$/;" k type:dl +b testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integer :: a, b$/;" k type:dl +b testsuite/libgomp.fortran/allocatable1.f90 /^ integer :: b(/;" v +b testsuite/libgomp.fortran/allocatable10.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/allocatable11.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/allocatable12.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/allocatable2.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/allocatable4.f90 /^ integer :: b(/;" v +b testsuite/libgomp.fortran/allocatable6.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/allocatable9.f90 /^ integer, allocatabl/;" v +b testsuite/libgomp.fortran/crayptr1.f90 /^ integer :: a, b,/;" v +b testsuite/libgomp.fortran/crayptr2.f90 /^ integer :: a, b,/;" v +b testsuite/libgomp.fortran/crayptr3.f90 /^ integer :: a, b,/;" v +b testsuite/libgomp.fortran/declare-simd-1.f90 /^ real :: b(/;" v +b testsuite/libgomp.fortran/do1.f90 /^ integer, dimension (128) :: a, b$/;" v +b testsuite/libgomp.fortran/do2.f90 /^ integer, dimension (128) :: a, b$/;" v +b testsuite/libgomp.fortran/doacross1.f90 /^ integer, save :: a(N), b(/;" v +b testsuite/libgomp.fortran/doacross2.f90 /^ integer, save :: a(N), b(/;" v +b testsuite/libgomp.fortran/doacross3.f90 /^ integer, save :: a(N), b(/;" v +b testsuite/libgomp.fortran/examples-4/device-1.f90 /^ integer :: a, b$/;" v program:e_57_1 +b testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ doubl/;" v program:SIMD1 +b testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ doubl/;" v program:main +b testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ doubl/;" v program:SIMD3 +b testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ real :: b(/;" v program:SIMD4 +b testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ doubl/;" v program:SIMD5 +b testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ integer :: a(0:N-1), b(/;" v program:fibonacci +b testsuite/libgomp.fortran/nestedfn1.f90 /^ integer :: a, b,/;" v +b testsuite/libgomp.fortran/omp_atomic1.f90 /^ integer (kind = 2) :: b$/;" v +b testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer (kind = 2) :: a, b,/;" v +b testsuite/libgomp.fortran/omp_atomic3.f90 /^ integer (kind = 2) :: b,/;" v +b testsuite/libgomp.fortran/omp_atomic4.f90 /^ integer (kind = 2) :: b,/;" v +b testsuite/libgomp.fortran/omp_atomic5.f90 /^ integer (kind = 2) :: b,/;" v +b testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.fortran/pointer1.f90 /^ integer, target :: b,/;" v +b testsuite/libgomp.fortran/pr42162.f90 /^ integer :: k, a(3), b(/;" v program:pr42162 +b testsuite/libgomp.fortran/pr49792-2.f90 /^ integer :: b(/;" v program:pr49792 +b testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b,/;" v +b testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b,/;" v +b testsuite/libgomp.fortran/pr81304.f90 /^ real, dimension(1:3) :: a, b,/;" v program:pr81304 +b testsuite/libgomp.fortran/pr81841.f90 /^ real :: b(/;" v +b testsuite/libgomp.fortran/reference2.f90 /^ real, dimension (5) :: b$/;" v +b testsuite/libgomp.fortran/sharing1.f90 6;" c +b testsuite/libgomp.fortran/simd2.f90 /^ integer :: a(1024), b(/;" v +b testsuite/libgomp.fortran/simd3.f90 /^ integer :: a(1024), b(/;" v +b testsuite/libgomp.fortran/simd4.f90 /^ integer :: a(1024), b(/;" v +b testsuite/libgomp.fortran/simd5.f90 /^ integer :: i, j, b,/;" v +b testsuite/libgomp.fortran/simd6.f90 /^ integer :: i, j, b,/;" v +b testsuite/libgomp.fortran/tabs1.f90 /^function b(/;" f +b testsuite/libgomp.fortran/tabs2.f /^ function b(/;" f +b testsuite/libgomp.fortran/target2.f90 /^ integer :: a, b(/;" v +b testsuite/libgomp.fortran/udr12.f90 /^ integer :: a(10), b,/;" v +b testsuite/libgomp.fortran/udr13.f90 /^ integer :: a(10), b(/;" v +b testsuite/libgomp.fortran/udr15.f90 /^ integer :: b$/;" v module:udr15m1 +b testsuite/libgomp.fortran/udr8.f90 /^ integer :: b$/;" v module:udr8m1 +b testsuite/libgomp.fortran/udr9.f90 /^ integer :: b$/;" v module:udr9m1 +b testsuite/libgomp.fortran/workshare1.f90 /^ integer :: a (10), b /;" v +b testsuite/libgomp.hsa.c/bitfield-1.c /^ unsigned b : 20;$/;" m struct:S1 file: +b testsuite/libgomp.oacc-c-c++-common/declare-1.c /^int b[8];$/;" v +b testsuite/libgomp.oacc-c-c++-common/declare-2.c /^float b[N];$/;" v +b testsuite/libgomp.oacc-c-c++-common/declare-4.c /^float b;$/;" v +b testsuite/libgomp.oacc-c-c++-common/vector-loop.c /^unsigned int b[N];$/;" v +b testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/clauses-1.f90 /^ real, allocatabl/;" v program:main +b testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ integer :: i, j, k, a(1:7, -3:5, 12:19), b(/;" v program:collapse4 +b testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: i, j, k, a(1:7, -3:5, 12:19), b(/;" v program:collapse5 +b testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: i, j, k, a(1:7, -3:5, 12:19), b(/;" v program:collapse6 +b testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ integer :: i, j, k, a(1:7, -3:5, 12:19), b(/;" v program:collapse7 +b testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: i, j, k, a(1:7, -3:5, 12:19), b(/;" v program:collapse8 +b testsuite/libgomp.oacc-fortran/combined-directives-1.f90 /^ real :: a(n), b(/;" v program:main +b testsuite/libgomp.oacc-fortran/data-1.f90 /^ real, allocatabl/;" v program:test +b testsuite/libgomp.oacc-fortran/data-2.f90 /^ real, allocatabl/;" v program:test +b testsuite/libgomp.oacc-fortran/data-3.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/data-4.f90 /^ real, allocatabl/;" v program:asyncwait +b testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer :: b(/;" v program:main +b testsuite/libgomp.oacc-fortran/declare-3.f90 /^ real b$/;" v module:globalvars +b testsuite/libgomp.oacc-fortran/declare-4.f90 /^ real b$/;" v module:vars +b testsuite/libgomp.oacc-fortran/declare-5.f90 /^ real b$/;" v module:vars +b testsuite/libgomp.oacc-fortran/default-1.f90 /^ real a, b$/;" v program:main +b testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ integer :: a, b(/;" v program:firstprivate +b testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^ integer i, a(n), b(/;" v program:main +b testsuite/libgomp.oacc-fortran/if-1.f90 /^ real, allocatabl/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ integer, dimension (0:n-1) :: a, b,/;" v program:main +b testsuite/libgomp.oacc-fortran/map-1.f90 /^ integer :: i, a(n), b(/;" v +b testsuite/libgomp.oacc-fortran/routine-7.f90 /^ integer :: b(/;" v program:main +b testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^ integer :: i, a(n), b(/;" v program:subarrays +b testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ integer :: i, a(n), b(/;" v program:subarrays +b testsuite/libgomp.oacc-fortran/update-1.f90 /^ real :: a(N), b(/;" v program:update +b1 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1,/;" v +b1 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1,/;" v +b1 testsuite/libgomp.oacc-fortran/pset-1.f90 /^ integer, allocatable :: b1(/;" v program:test +b2 testsuite/libgomp.fortran/omp_atomic3.f90 /^ integer (kind = 2) :: b, b2$/;" v +b2 testsuite/libgomp.fortran/omp_atomic4.f90 /^ integer (kind = 2) :: b, b2$/;" v +b2 testsuite/libgomp.fortran/omp_atomic5.f90 /^ integer (kind = 2) :: b, b2$/;" v +b2 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2,/;" v +b2 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2,/;" v +b2 testsuite/libgomp.oacc-fortran/pset-1.f90 /^ integer, allocatable :: b2(/;" v program:test +b_ref testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ real :: b(128), b_ref(/;" v program:SIMD4 +bar config/posix/simple-bar.h /^ gomp_barrier_t bar;$/;" m struct:__anon33 +bar configure /^bar();$/;" f +bar testsuite/libgomp.c++/atomic-1.C /^bar (T *x, T y)$/;" f +bar testsuite/libgomp.c++/atomic-13.C /^bar ()$/;" f +bar testsuite/libgomp.c++/atomic-3.C /^bar ()$/;" f +bar testsuite/libgomp.c++/atomic-5.C /^bar ()$/;" f +bar testsuite/libgomp.c++/atomic-9.C /^bar ()$/;" f +bar testsuite/libgomp.c++/pr27337.C /^bar ()$/;" f +bar testsuite/libgomp.c++/pr30703.C /^bar ()$/;" f +bar testsuite/libgomp.c++/pr35185.C /^bar (S s)$/;" f +bar testsuite/libgomp.c++/pr39573.C /^bar (int *x)$/;" f +bar testsuite/libgomp.c++/pr58706.C /^bar ()$/;" f +bar testsuite/libgomp.c++/pr63248.C /^bar (int A, int B)$/;" f +bar testsuite/libgomp.c++/pr66702-1.C /^bar (int &a, int &b, int *&c, int &d)$/;" f +bar testsuite/libgomp.c++/pr81314.C /^bar (S<3> &x)$/;" f +bar testsuite/libgomp.c++/simd-3.C /^bar (int *p, long int n, long int o)$/;" f +bar testsuite/libgomp.c++/simd-6.C /^bar (S &s, S &t)$/;" f +bar testsuite/libgomp.c++/simd-7.C /^bar (S &s, S &t)$/;" f +bar testsuite/libgomp.c++/simd-9.C /^bar (int &u, int &v)$/;" f +bar testsuite/libgomp.c++/simd14.C /^bar (int &x, unsigned long long &y, short *&z)$/;" f file: +bar testsuite/libgomp.c++/target-13.C /^bar (void)$/;" f +bar testsuite/libgomp.c++/target-20.C /^bar (S &s, T &t, U u)$/;" f +bar testsuite/libgomp.c++/target-21.C /^bar (S s)$/;" f +bar testsuite/libgomp.c++/target-7.C /^bar (int n, int v)$/;" f +bar testsuite/libgomp.c++/target-8.C /^bar (T &a, int &b, struct S &c)$/;" f +bar testsuite/libgomp.c++/task-3.C /^bar (int i, A a)$/;" f +bar testsuite/libgomp.c++/task-5.C /^bar (int i, A a)$/;" f +bar testsuite/libgomp.c++/udr-1.C /^bar (S &x)$/;" f +bar testsuite/libgomp.c++/udr-6.C /^void bar (T &x, T &y, int z)$/;" f +bar testsuite/libgomp.c++/udr-7.C /^bar (S &x, S &y)$/;" f +bar testsuite/libgomp.c++/udr-8.C /^bar (S &x, S &y)$/;" f +bar testsuite/libgomp.c/atomic-12.c /^bar (void)$/;" f +bar testsuite/libgomp.c/autopar-1.c /^bar (void)$/;" f +bar testsuite/libgomp.c/icv-2.c /^pthread_barrier_t bar;$/;" v +bar testsuite/libgomp.c/lock-3.c /^pthread_barrier_t bar;$/;" v +bar testsuite/libgomp.c/pr30494.c /^bar (int n, int m)$/;" f +bar testsuite/libgomp.c/pr45784.c /^bar (int n)$/;" f +bar testsuite/libgomp.c/pr58392.c /^bar (int a)$/;" f +bar testsuite/libgomp.c/pr58756.c /^bar (int a)$/;" f +bar testsuite/libgomp.c/pr61200.c /^bar ()$/;" f +bar testsuite/libgomp.c/pr64734.c /^bar (void)$/;" f +bar testsuite/libgomp.c/pr64868.c /^bar ()$/;" f +bar testsuite/libgomp.c/simd-3.c /^bar (int *p, long int n, long int o)$/;" f +bar testsuite/libgomp.c/simd-7.c /^bar (int *p)$/;" f +bar testsuite/libgomp.c/simd-9.c /^bar (void)$/;" f +bar testsuite/libgomp.c/static-chunk-size-one.c /^bar ()$/;" f +bar testsuite/libgomp.c/target-15.c /^bar (int n, int v)$/;" f +bar testsuite/libgomp.c/target-16.c /^bar (int n)$/;" f +bar testsuite/libgomp.c/target-28.c /^bar (void)$/;" f +bar testsuite/libgomp.c/target-35.c /^bar (int x, int y, int z)$/;" f +bar testsuite/libgomp.c/target-link-1.c /^bar (int n)$/;" f +bar testsuite/libgomp.c/target-teams-1.c /^bar (long *x, long *y)$/;" f +bar testsuite/libgomp.c/taskloop-1.c /^bar (int a, int b)$/;" f +bar testsuite/libgomp.c/udr-1.c /^bar (struct S *x)$/;" f +bar testsuite/libgomp.fortran/declare-simd-1.f90 /^function bar /;" f +bar testsuite/libgomp.fortran/declare-simd-3.f90 /^subroutine bar$/;" s +bar testsuite/libgomp.fortran/nestedfn3.f90 /^ subroutine bar$/;" s program:nestomp +bar testsuite/libgomp.fortran/nestedfn5.f90 /^subroutine bar /;" s +bar testsuite/libgomp.fortran/omp_atomic2.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/pointer1.f90 /^ subroutine bar /;" s +bar testsuite/libgomp.fortran/procptr1.f90 /^integer function bar /;" f +bar testsuite/libgomp.fortran/reference2.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/simd2.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/simd3.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/simd4.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/taskloop1.f90 /^ function bar /;" f +bar testsuite/libgomp.fortran/udr14.f90 /^ subroutine bar /;" s +bar testsuite/libgomp.fortran/workshare1.f90 /^ integer :: a (10), b (10), foo, bar$/;" v +bar testsuite/libgomp.fortran/workshare1.f90 /^function bar /;" f +bar testsuite/libgomp.hsa.c/formal-actual-args-1.c /^bar (int a)$/;" f +bar testsuite/libgomp.hsa.c/gridify-3.c /^bar (int j, int n, int *a)$/;" f +bar testsuite/libgomp.hsa.c/gridify-4.c /^bar (int j, int n, int *a)$/;" f +bar1 testsuite/libgomp.fortran/threadprivate2.f90 /^ integer, dimension(:), pointer :: bar1$/;" v +bar1 testsuite/libgomp.fortran/threadprivate3.f90 /^ integer, dimension(:), pointer :: bar1$/;" v +bar2 testsuite/libgomp.c++/target-21.C /^bar2 (S &s)$/;" f +bar2 testsuite/libgomp.fortran/threadprivate2.f90 /^ integer, dimension(2), target :: bar2$/;" v +bar2 testsuite/libgomp.fortran/threadprivate3.f90 /^ integer, dimension(2), target :: bar2,/;" v +bar3 testsuite/libgomp.c++/target-21.C /^bar3 (U s)$/;" f +bar3 testsuite/libgomp.fortran/threadprivate2.f90 /^ integer, dimension(:), pointer, save :: bar3 /;" v +bar3 testsuite/libgomp.fortran/threadprivate3.f90 /^ integer, dimension(:), pointer, save :: bar3 /;" v +bar4 testsuite/libgomp.c++/target-21.C /^bar4 (U &s)$/;" f +bar_seen testsuite/libgomp.fortran/workshare1.f90 /^ logical :: foo_seen, bar_seen$/;" v +bar_seen testsuite/libgomp.fortran/workshare1.f90 11;" c function:bar +bar_seen testsuite/libgomp.fortran/workshare1.f90 18;" c +barp testsuite/libgomp.c++/pr66702-1.C /^void (*volatile barp) (int &, int &, int *&, int &) = bar;$/;" v +barrier libgomp.h /^ gomp_barrier_t barrier;$/;" m struct:gomp_team +base testsuite/libgomp.c++/ctor-10.C /^ static B *base;$/;" m struct:B file: +base testsuite/libgomp.c++/ctor-10.C /^B *B::base;$/;" m class:B file: +base testsuite/libgomp.c++/ctor-8.C /^static B *base;$/;" v file: +base testsuite/libgomp.c++/ctor-9.C /^static B *base;$/;" v file: +base_dev oacc-int.h /^ struct gomp_device_descr *base_dev;$/;" m struct:goacc_thread typeref:struct:goacc_thread::gomp_device_descr +baz testsuite/libgomp.c++/atomic-1.C /^baz ()$/;" f +baz testsuite/libgomp.c++/doacross-1.C /^baz (I &i, I &j, I &k, T &l)$/;" f +baz testsuite/libgomp.c++/doacross-1.C /^baz (T &i, T &j, T &k, T &l)$/;" f +baz testsuite/libgomp.c++/for-1.C /^baz (I &i)$/;" f +baz testsuite/libgomp.c++/for-2.C /^baz (int i)$/;" f +baz testsuite/libgomp.c++/for-3.C /^baz (T &i)$/;" f +baz testsuite/libgomp.c++/for-4.C /^baz (T &i)$/;" f +baz testsuite/libgomp.c++/for-5.C /^baz (I &i)$/;" f +baz testsuite/libgomp.c++/for-8.C /^baz (I &i)$/;" f +baz testsuite/libgomp.c++/pr58706.C /^baz ()$/;" f +baz testsuite/libgomp.c++/pr63248.C /^baz (int A, int B)$/;" f +baz testsuite/libgomp.c++/task-3.C /^baz ()$/;" f +baz testsuite/libgomp.c++/task-4.C /^baz (int i, int *p, int j, int *q)$/;" f +baz testsuite/libgomp.c++/task-5.C /^baz ()$/;" f +baz testsuite/libgomp.c++/taskloop-6.C /^baz (I &i)$/;" f +baz testsuite/libgomp.c++/taskloop-7.C /^baz (T &i)$/;" f +baz testsuite/libgomp.c++/taskloop-8.C /^baz (T &i)$/;" f +baz testsuite/libgomp.c++/taskloop-9.C /^baz (I &i)$/;" f +baz testsuite/libgomp.c++/udr-2.C /^ void baz (int v)$/;" f struct:NS::S +baz testsuite/libgomp.c++/udr-2.C /^ void baz ()$/;" f struct:T +baz testsuite/libgomp.c++/udr-3.C /^ void baz (int v)$/;" f struct:NS::S +baz testsuite/libgomp.c++/udr-3.C /^ void baz ()$/;" f struct:T +baz testsuite/libgomp.c++/udr-3.C /^ void baz ()$/;" f struct:V +baz testsuite/libgomp.c++/udr-5.C /^ static void baz (S &x, S &y) { x.a += y.a; }$/;" f struct:S +baz testsuite/libgomp.c++/udr-5.C /^ static void baz (T &x, T &y) { x.a += y.a; }$/;" f struct:T +baz testsuite/libgomp.c++/udr-7.C /^baz (S &x, S &y)$/;" f +baz testsuite/libgomp.c++/udr-7.C /^baz (S x)$/;" f +baz testsuite/libgomp.c/pr52547.c /^baz (int *x, int (*fn) (int *))$/;" f +baz testsuite/libgomp.c/pr58392.c /^baz (int a)$/;" f file: +baz testsuite/libgomp.c/pr58756.c /^baz (int a)$/;" f file: +baz testsuite/libgomp.c/target-teams-1.c /^baz (void)$/;" f +baz testsuite/libgomp.c/task-4.c /^baz (int i, int *p, int j, int *q)$/;" f +baz testsuite/libgomp.c/udr-1.c /^baz (struct S *x, struct S *y)$/;" f +baz testsuite/libgomp.fortran/declare-simd-1.f90 /^ function baz /;" f +baz testsuite/libgomp.fortran/procptr1.f90 /^integer function baz /;" f +baz testsuite/libgomp.fortran/simd2.f90 /^ function baz /;" f +baz testsuite/libgomp.fortran/simd3.f90 /^ function baz /;" f +baz testsuite/libgomp.fortran/simd4.f90 /^ function baz /;" f +baz testsuite/libgomp.fortran/threadprivate2.f90 /^ type (tt), save :: baz$/;" v +baz testsuite/libgomp.fortran/threadprivate3.f90 /^ type (tt), save :: baz$/;" v +baz testsuite/libgomp.hsa.c/formal-actual-args-1.c /^baz (struct Cube c)$/;" f +bb testsuite/libgomp.c++/reduction-10.C /^B bb;$/;" v +bb testsuite/libgomp.c++/reduction-11.C /^short bb[5];$/;" v +bb testsuite/libgomp.c++/reduction-12.C /^B bb;$/;" v +bb testsuite/libgomp.c++/reduction-5.C /^short bb[5];$/;" v +bb testsuite/libgomp.c++/reduction-6.C /^B bb;$/;" v +bb testsuite/libgomp.c++/reduction-7.C /^short bb[5];$/;" v +bb testsuite/libgomp.c++/reduction-8.C /^B bb;$/;" v +bb testsuite/libgomp.c++/reduction-9.C /^short bb[5];$/;" v +begin testsuite/libgomp.c++/collapse-2.C /^template const I &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-1.C /^template const I &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-2.C /^template T J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-3.C /^const typename std::vector::const_iterator &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-4.C /^const typename std::basic_string::iterator &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-5.C /^template const I &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/for-8.C /^template const I &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/taskloop-6.C /^template const I &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/taskloop-7.C /^const typename std::vector::const_iterator &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/taskloop-8.C /^const typename std::basic_string::iterator &J::begin () { return b; }$/;" f class:J +begin testsuite/libgomp.c++/taskloop-9.C /^template const I &J::begin () { return b; }$/;" f class:J +beginning tdg.c /^struct data_to_free *beginning = NULL;$/;" v typeref:struct:data_to_free +bind_var libgomp.h /^ char bind_var;$/;" m struct:gomp_task_icv +blk testsuite/libgomp.fortran/taskloop1.f90 14;" c subroutine:foo +blk testsuite/libgomp.fortran/taskloop1.f90 1;" c +blk testsuite/libgomp.fortran/taskloop1.f90 29;" c function:bar +boundary libgomp.h /^ long boundary;$/;" m union:gomp_doacross_work_share::__anon45 +boundary_ull libgomp.h /^ unsigned long long boundary_ull;$/;" m union:gomp_doacross_work_share::__anon45 +br testsuite/libgomp.c++/target-2.C /^double (&br) [1024] = b;$/;" v +break_exceptions_mask plugin/hsa_ext_finalize.h /^ uint16_t break_exceptions_mask;$/;" m struct:hsa_ext_control_directives_s +brig_image_desc plugin/plugin-hsa.c /^struct brig_image_desc$/;" s file: +brig_libraries plugin/plugin-hsa.c /^ struct brig_library_info **brig_libraries;$/;" m struct:agent_info typeref:struct:agent_info::brig_library_info file: +brig_libraries_count plugin/plugin-hsa.c /^ unsigned brig_libraries_count;$/;" m struct:agent_info file: +brig_library_info plugin/plugin-hsa.c /^struct brig_library_info$/;" s file: +brig_module plugin/plugin-hsa.c /^ hsa_ext_module_t brig_module;$/;" m struct:brig_image_desc file: +buf testsuite/libgomp.c++/copyin-2.C /^struct S { int t; char buf[64]; } thr = { 32, "" };$/;" m struct:S file: +buf testsuite/libgomp.c/copyin-2.c /^struct { int t; char buf[64]; } thr = { 32, "" };$/;" m struct:__anon27 file: +buf testsuite/libgomp.c/loop-8.c /^int buf[256];$/;" v +buf testsuite/libgomp.c/loop-9.c /^char buf[8] = "01234567";$/;" v +buf2 testsuite/libgomp.c/loop-9.c /^char buf2[8] = "23456789";$/;" v +build_TDG_from_hash tdg.c /^void build_TDG_from_hash ()$/;" f +bump testsuite/libgomp.c++/cancel-test.h /^ bump ()$/;" f struct:S +busy_wait testsuite/libgomp.c/sort-1.c /^busy_wait (void)$/;" f file: +c testsuite/libgomp.c++/member-1.C /^int c;$/;" v +c testsuite/libgomp.c++/member-2.C /^int c, d, e;$/;" v +c testsuite/libgomp.c++/member-3.C /^int c;$/;" v +c testsuite/libgomp.c++/member-4.C /^int c, d, e;$/;" v +c testsuite/libgomp.c++/member-6.C /^int c;$/;" v +c testsuite/libgomp.c++/member-7.C /^int c, d, e;$/;" v +c testsuite/libgomp.c++/pr66702-1.C /^int c[64] __attribute__((aligned (32)));$/;" v +c testsuite/libgomp.c++/pr81130.C /^ int c;$/;" m struct:B file: +c testsuite/libgomp.c++/simd-3.C /^unsigned char c[1024] __attribute__((aligned (32))) = { 1 };$/;" v +c testsuite/libgomp.c++/single-2.C /^ int c;$/;" m struct:X file: +c testsuite/libgomp.c++/target-10.C /^struct T { int a; union U b; int c; };$/;" m struct:T file: +c testsuite/libgomp.c++/target-11.C /^struct T { int a; int *b; int c; char (&d)[10]; };$/;" m struct:T file: +c testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +c testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +c testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +c testsuite/libgomp.c++/target-2.C /^double *c = cbuf;$/;" v +c testsuite/libgomp.c++/target-20.C /^struct S { int a, b, c, d; };$/;" m struct:S file: +c testsuite/libgomp.c++/udr-6.C /^struct C { int c; C () : c (4) {} };$/;" m struct:C file: +c testsuite/libgomp.c/doacross-1.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8];$/;" v +c testsuite/libgomp.c/doacross-2.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +c testsuite/libgomp.c/doacross-3.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +c testsuite/libgomp.c/omp-single-2.c /^ int c;$/;" m struct:X file: +c testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.c/pr26943-2.c /^int a = 8, b = 12, c = 16, d = 20, j = 0;$/;" v +c testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +c testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +c testsuite/libgomp.c/pr81875.c /^const unsigned long long c = 0x7fffffffffffffffULL;$/;" v +c testsuite/libgomp.c/reduction-15.c /^int a[16], b[16], c[16], d[5][2];$/;" v +c testsuite/libgomp.c/simd-3.c /^unsigned char c[1024] __attribute__((aligned (32))) = { 1 };$/;" v +c testsuite/libgomp.c/target-21.c /^struct T { int a; union U b; int c; };$/;" m struct:T file: +c testsuite/libgomp.c/target-22.c /^struct T { int a; int *b; int c; };$/;" m struct:T file: +c testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +c testsuite/libgomp.c/target-31.c /^int a = 1, b = 2, c = 3, d = 4;$/;" v +c testsuite/libgomp.c/target-link-1.c /^double c[27];$/;" v +c testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integer, alloca/;" k type:dl +c testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integer, alloca/;" k type:dl +c testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integer, alloca/;" k type:dl +c testsuite/libgomp.fortran/allocatable10.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/allocatable11.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/allocatable12.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/allocatable6.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/allocatable9.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/associate2.f90 /^ type(dl) :: c(/;" k type:dt +c testsuite/libgomp.fortran/crayptr1.f90 /^ integer :: a, b, c,/;" v +c testsuite/libgomp.fortran/crayptr2.f90 /^ integer :: a, b, c,/;" v +c testsuite/libgomp.fortran/crayptr3.f90 /^ integer :: a, b, c,/;" v +c testsuite/libgomp.fortran/doacross1.f90 /^ integer, save :: a(N), b(N \/ 16, 8, 4), c(/;" v +c testsuite/libgomp.fortran/doacross2.f90 /^ integer, save :: a(N), b(N \/ 16, 8, 4), c(/;" v +c testsuite/libgomp.fortran/doacross3.f90 /^ integer, save :: a(N), b(N \/ 16, 8, 4), c(/;" v +c testsuite/libgomp.fortran/examples-4/device-1.f90 /^ logica/;" v program:e_57_1 +c testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ double preci/;" v program:SIMD1 +c testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ double preci/;" v program:SIMD5 +c testsuite/libgomp.fortran/lastprivate1.f90 108;" c subroutine:test11 +c testsuite/libgomp.fortran/lastprivate1.f90 118;" c subroutine:test12 +c testsuite/libgomp.fortran/lastprivate1.f90 28;" c subroutine:test1 +c testsuite/libgomp.fortran/lastprivate1.f90 35;" c subroutine:test2 +c testsuite/libgomp.fortran/lastprivate1.f90 3;" c program:lastprivate +c testsuite/libgomp.fortran/lastprivate1.f90 46;" c subroutine:test3 +c testsuite/libgomp.fortran/lastprivate1.f90 74;" c subroutine:test7 +c testsuite/libgomp.fortran/lastprivate1.f90 82;" c subroutine:test8 +c testsuite/libgomp.fortran/lastprivate1.f90 90;" c subroutine:test9 +c testsuite/libgomp.fortran/lastprivate1.f90 98;" c subroutine:test10 +c testsuite/libgomp.fortran/lastprivate2.f90 109;" c subroutine:test10 +c testsuite/libgomp.fortran/lastprivate2.f90 120;" c subroutine:test11 +c testsuite/libgomp.fortran/lastprivate2.f90 131;" c subroutine:test12 +c testsuite/libgomp.fortran/lastprivate2.f90 28;" c subroutine:test1 +c testsuite/libgomp.fortran/lastprivate2.f90 36;" c subroutine:test2 +c testsuite/libgomp.fortran/lastprivate2.f90 3;" c program:lastprivate +c testsuite/libgomp.fortran/lastprivate2.f90 48;" c subroutine:test3 +c testsuite/libgomp.fortran/lastprivate2.f90 81;" c subroutine:test7 +c testsuite/libgomp.fortran/lastprivate2.f90 90;" c subroutine:test8 +c testsuite/libgomp.fortran/lastprivate2.f90 99;" c subroutine:test9 +c testsuite/libgomp.fortran/nestedfn1.f90 /^ integer :: a, b, c$/;" v +c testsuite/libgomp.fortran/nestedfn2.f90 18;" c subroutine:test2 +c testsuite/libgomp.fortran/nestedfn2.f90 26;" c subroutine:test3 +c testsuite/libgomp.fortran/nestedfn2.f90 4;" c +c testsuite/libgomp.fortran/nestedfn4.f90 /^ integer :: a(10), c(/;" v program:foo +c testsuite/libgomp.fortran/omp_atomic1.f90 /^ real :: c,/;" v +c testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer (kind = 2) :: a, b, c$/;" v +c testsuite/libgomp.fortran/omp_atomic3.f90 /^ real :: c,/;" v +c testsuite/libgomp.fortran/omp_atomic4.f90 /^ real :: c$/;" v +c testsuite/libgomp.fortran/omp_atomic5.f90 /^ real :: c$/;" v +c testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.fortran/pointer1.f90 /^ integer, pointer :: a, c(/;" v +c testsuite/libgomp.fortran/pr42162.f90 /^ integer :: k, a(3), b(3), c(/;" v program:pr42162 +c testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c,/;" v +c testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c,/;" v +c testsuite/libgomp.fortran/pr81304.f90 /^ real, dimension(1:3) :: a, b, c$/;" v program:pr81304 +c testsuite/libgomp.fortran/pr81841.f90 17;" c program:pr81841 +c testsuite/libgomp.fortran/pr81841.f90 7;" c +c testsuite/libgomp.fortran/reduction1.f90 /^ co/;" v +c testsuite/libgomp.fortran/reduction6.f90 /^ ch/;" v +c testsuite/libgomp.fortran/simd5.f90 /^ integer :: i, j, b, c$/;" v +c testsuite/libgomp.fortran/simd6.f90 /^ integer :: i, j, b, c$/;" v +c testsuite/libgomp.fortran/target2.f90 /^ integer :: a, b(2:n-1), c(/;" v +c testsuite/libgomp.fortran/target7.f90 /^ integer, parameter :: c /;" v +c testsuite/libgomp.fortran/target8.f90 /^ integer, parameter :: c /;" v +c testsuite/libgomp.fortran/udr13.f90 /^ integer, alloca/;" v +c testsuite/libgomp.fortran/udr3.f90 /^ ch/;" v +c testsuite/libgomp.fortran/udr4.f90 /^ ch/;" v +c testsuite/libgomp.fortran/vla7.f90 /^ ch/;" v +c testsuite/libgomp.oacc-c-c++-common/declare-2.c /^float c[N];$/;" v +c testsuite/libgomp.oacc-c-c++-common/vector-loop.c /^unsigned int c[N];$/;" v +c testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/clauses-1.f90 /^ real, alloca/;" v program:main +c testsuite/libgomp.oacc-fortran/data-3.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/data-4.f90 /^ real, alloca/;" v program:asyncwait +c testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer :: c(/;" v program:main +c testsuite/libgomp.oacc-fortran/declare-3.f90 /^ real c$/;" v program:test +c testsuite/libgomp.oacc-fortran/default-1.f90 /^ real c$/;" v program:main +c testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ integer :: a, b(Nupper), c,/;" v program:firstprivate +c testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ integer, dimension (0:n-1) :: a, b, c$/;" v program:main +c testsuite/libgomp.oacc-fortran/lib-10.f90 /^ co/;" v program:main +c testsuite/libgomp.oacc-fortran/lib-8.f90 /^ co/;" v program:main +c testsuite/libgomp.oacc-fortran/map-1.f90 /^ integer, parameter :: n = 20, c /;" v +c testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer, parameter :: n = 40, c /;" v program:reduction +c testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^ integer, parameter :: n = 20, c /;" v program:subarrays +c testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ integer, parameter :: n = 20, c /;" v program:subarrays +c1 testsuite/libgomp.hsa.c/builtins-1.c 9;" d file: +c1 testsuite/libgomp.oacc-fortran/pset-1.f90 /^ integer, allocatable :: c1(/;" v program:test +c2 testsuite/libgomp.fortran/omp_atomic3.f90 /^ double precision :: d, d2, c2$/;" v +c2 testsuite/libgomp.fortran/omp_atomic4.f90 /^ double precision :: d, d2, c2$/;" v +c2 testsuite/libgomp.fortran/omp_atomic5.f90 /^ double precision :: d, d2, c2$/;" v +c2 testsuite/libgomp.hsa.c/builtins-1.c 10;" d file: +c3 testsuite/libgomp.oacc-fortran/pset-1.f90 /^ integer, allocatable :: c3(/;" v program:test +c_ref testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ double precision, dimension(32, 32) :: a, b, c, c_ref$/;" v program:SIMD5 +c_size testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer, parameter :: c_size /;" v program:main +c_size testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer, parameter :: c_size /;" v program:main +ca testsuite/libgomp.fortran/reduction1.f90 /^ complex :: c, ca /;" v +cached_base_dev oacc-init.c /^static struct gomp_device_descr *cached_base_dev = NULL;$/;" v typeref:struct:gomp_device_descr file: +calculate_firstprivate_requirements target.c /^calculate_firstprivate_requirements (size_t mapnum, size_t *sizes,$/;" f file: +can_run_func libgomp.h /^ __typeof (GOMP_OFFLOAD_can_run) *can_run_func;$/;" m struct:gomp_device_descr +cancellable config/posix/bar.h /^ bool cancellable;$/;" m struct:__anon35 +cancelled libgomp.h /^ bool cancelled;$/;" m struct:gomp_taskgroup +capabilities libgomp.h /^ unsigned int capabilities;$/;" m struct:gomp_device_descr +cbtype priority_queue.c /^struct cbtype$/;" s file: +cbuf testsuite/libgomp.c++/target-2.C /^double cbuf[1024];$/;" v +cc testsuite/libgomp.c++/ctor-13.C /^ static int ic, dc, xc, ac, cc;$/;" m struct:B file: +cc testsuite/libgomp.c++/ctor-13.C /^int B::cc;$/;" m class:B file: +ccount testsuite/libgomp.c++/ctor-11.C /^ static int ccount;$/;" m struct:B file: +ccount testsuite/libgomp.c++/ctor-11.C /^int B::ccount;$/;" m class:B file: +ccount testsuite/libgomp.c++/ctor-2.C /^ static int ccount;$/;" m struct:B file: +ccount testsuite/libgomp.c++/ctor-2.C /^int B::ccount;$/;" m class:B file: +ccount testsuite/libgomp.c++/ctor-3.C /^ static int ccount;$/;" m struct:B file: +ccount testsuite/libgomp.c++/ctor-3.C /^int B::ccount;$/;" m class:B file: +ccount testsuite/libgomp.c++/ctor-4.C /^ static int ccount;$/;" m struct:B file: +ccount testsuite/libgomp.c++/ctor-4.C /^int B::ccount;$/;" m class:B file: +cctor testsuite/libgomp.c++/pr30703.C /^int ctor, cctor, dtor;$/;" v +channel_order plugin/hsa_ext_finalize.h /^ hsa_ext_image_channel_order_t channel_order;$/;" m struct:hsa_ext_image_format_s +channel_type plugin/hsa_ext_finalize.h /^ hsa_ext_image_channel_type_t channel_type;$/;" m struct:hsa_ext_image_format_s +check testsuite/libgomp.c++/atomic-1.C /^int check;$/;" v +check testsuite/libgomp.c++/doacross-1.C 223;" d file: +check testsuite/libgomp.c++/examples-4/target_data-5.C /^void check (float *a, float *b, int n)$/;" f +check testsuite/libgomp.c++/for-1.C 234;" d file: +check testsuite/libgomp.c++/for-2.C 144;" d file: +check testsuite/libgomp.c++/for-3.C 179;" d file: +check testsuite/libgomp.c++/for-4.C 178;" d file: +check testsuite/libgomp.c++/for-5.C 237;" d file: +check testsuite/libgomp.c++/for-8.C 234;" d file: +check testsuite/libgomp.c++/loop-12.C 20;" d file: +check testsuite/libgomp.c++/loop-5.C /^int check;$/;" v +check testsuite/libgomp.c++/loop-9.C 20;" d file: +check testsuite/libgomp.c++/task-3.C /^check (int i, A &a, int j, A &b)$/;" f +check testsuite/libgomp.c++/task-5.C /^check (int i, A &a, int j, A &b)$/;" f +check testsuite/libgomp.c++/taskloop-6.C 355;" d file: +check testsuite/libgomp.c++/taskloop-7.C 305;" d file: +check testsuite/libgomp.c++/taskloop-8.C 203;" d file: +check testsuite/libgomp.c++/taskloop-9.C 257;" d file: +check testsuite/libgomp.c/examples-4/async_target-1.c /^void check ()$/;" f +check testsuite/libgomp.c/examples-4/async_target-2.c /^void check (float *a, float *b, int n)$/;" f +check testsuite/libgomp.c/examples-4/declare_target-3.c /^void check ()$/;" f +check testsuite/libgomp.c/examples-4/declare_target-4.c /^void check (float a, float b)$/;" f +check testsuite/libgomp.c/examples-4/declare_target-5.c /^void check (float a, float b)$/;" f +check testsuite/libgomp.c/examples-4/simd-1.c /^void check (double *a, double *b)$/;" f +check testsuite/libgomp.c/examples-4/simd-2.c /^void check (double *a, double *b)$/;" f +check testsuite/libgomp.c/examples-4/simd-4.c /^void check (double *a, double *b)$/;" f +check testsuite/libgomp.c/examples-4/simd-5.c /^void check (double a[N][N], double b[N][N])$/;" f +check testsuite/libgomp.c/examples-4/target-1.c /^void check (int *a, int *b)$/;" f +check testsuite/libgomp.c/examples-4/target-2.c /^void check (char *a, char *b)$/;" f +check testsuite/libgomp.c/examples-4/target-3.c /^void check (long long *a, long long *b)$/;" f +check testsuite/libgomp.c/examples-4/target-4.c /^void check (double *a, double *b)$/;" f +check testsuite/libgomp.c/examples-4/target-5.c /^void check (float *a, float *b)$/;" f +check testsuite/libgomp.c/examples-4/target_data-1.c /^void check (long long *a, long long *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_data-2.c /^void check (char *a, char *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_data-3.c /^void check (int a[][COLS], int b[][COLS], const int rows, const int cols)$/;" f +check testsuite/libgomp.c/examples-4/target_data-4.c /^void check (double *a, double *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_data-6.c /^void check (float *a, float *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_data-7.c /^void check (short *a, short *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_update-1.c /^void check (int *a, int *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/target_update-2.c /^void check (int *a, int *b, int N)$/;" f +check testsuite/libgomp.c/examples-4/task_dep-5.c /^void check (float A[N][N], float B[N][N])$/;" f +check testsuite/libgomp.c/examples-4/teams-2.c /^void check (float a, float b)$/;" f +check testsuite/libgomp.c/examples-4/teams-3.c /^void check (float a, float b)$/;" f +check testsuite/libgomp.c/examples-4/teams-4.c /^void check (float a, float b)$/;" f +check testsuite/libgomp.c/examples-4/teams-5.c /^void check (float *a, float *b, int n)$/;" f +check testsuite/libgomp.c/examples-4/teams-6.c /^void check (float *a, float *b, int n)$/;" f +check testsuite/libgomp.c/loop-12.c 20;" d file: +check testsuite/libgomp.c/loop-6.c 20;" d file: +check testsuite/libgomp.c/ordered-3.c /^check (int x)$/;" f +check testsuite/libgomp.c/pr30494.c /^check (int m, int i, int *v, int *w)$/;" f +check testsuite/libgomp.c/pr46032.c /^check (unsigned *results)$/;" f file: +check testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ subroutine check /;" s module:SIMD1_mod +check testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ subroutine check /;" s module:SIMD2_mod +check testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ subroutine check /;" s module:SIMD4_mod +check testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ subroutine check /;" s module:SIMD5_mod +check testsuite/libgomp.fortran/examples-4/target-1.f90 /^ subroutine check /;" s module:e_50_1_mod +check testsuite/libgomp.fortran/examples-4/target-2.f90 /^ subroutine check /;" s module:e_50_2_mod +check testsuite/libgomp.fortran/examples-4/target-3.f90 /^ subroutine check /;" s module:e_50_3_mod +check testsuite/libgomp.fortran/examples-4/target-4.f90 /^ subroutine check /;" s module:e_50_4_mod +check testsuite/libgomp.fortran/examples-4/target-5.f90 /^ subroutine check /;" s module:e_50_5_mod +check testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^ subroutine check /;" s module:e_51_1_mod +check testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^ subroutine check /;" s module:e_51_2_mod +check testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ subroutine check /;" s module:e_51_3_mod +check testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ subroutine check /;" s module:e_51_4_mod +check testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ subroutine check /;" s module:e_51_5_mod +check testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^ subroutine check /;" s module:e_51_6_mod +check testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^ subroutine check /;" s module:e_51_7_mod +check testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ subroutine check /;" s module:e_52_1_mod +check testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ subroutine check /;" s module:e_52_2_mod +check testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ subroutine check /;" s module:task_dep5_mod +check testsuite/libgomp.fortran/examples-4/teams-2.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/teams-3.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/teams-4.f90 /^subroutine check /;" s +check testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ subroutine check /;" s module:e_54_5_mod +check testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ subroutine check /;" s module:e_54_6_mod +check testsuite/libgomp.fortran/task2.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla1.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla2.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla3.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla4.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla5.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla6.f90 /^ subroutine check /;" s +check testsuite/libgomp.fortran/vla8.f90 /^ subroutine check /;" s +check testsuite/libgomp.graphite/force-parallel-6.c /^check (void)$/;" f file: +check testsuite/libgomp.oacc-c-c++-common/kernels-loop-clauses.c /^check (int *a, int *b)$/;" f +check testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int check (const int *ary, int size, int gp, int wp, int vp)$/;" f +check testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c /^int check (const int *ary, int size, int gp, int wp, int vp)$/;" f +check testsuite/libgomp.oacc-c-c++-common/tile-1.c /^static int check (const int *ary, int size, int gp, int wp, int vp)$/;" f file: +check testsuite/libgomp.oacc-fortran/map-1.f90 /^subroutine check /;" s +check testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^subroutine check /;" s +check testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^subroutine check /;" s +check_addfloat testsuite/libgomp.c/examples-4/simd-6.c /^void check_addfloat (float *a, float *b)$/;" f +check_addint testsuite/libgomp.c/examples-4/simd-6.c /^void check_addint (int *a, int *b)$/;" f +check_deps priority_queue.c /^ bool check_deps;$/;" m struct:cbtype file: +check_reduction testsuite/libgomp.oacc-c-c++-common/reduction-5.c 20;" d file: +check_reduction_macro testsuite/libgomp.oacc-c-c++-common/reduction.h 23;" d +check_reduction_op testsuite/libgomp.oacc-c-c++-common/reduction.h 6;" d +checkfloat testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ subroutine checkfloat /;" s module:SIMD6_mod +checkint testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ subroutine checkint /;" s module:SIMD6_mod +children testsuite/libgomp.c/cancel-taskgroup-1.c /^struct T { struct T *children[2]; int val; };$/;" m struct:T typeref:struct:T::T file: +children_dispatches plugin/plugin-hsa.c /^ struct GOMP_hsa_kernel_dispatch **children_dispatches;$/;" m struct:GOMP_hsa_kernel_dispatch typeref:struct:GOMP_hsa_kernel_dispatch::GOMP_hsa_kernel_dispatch file: +children_queue libgomp.h /^ struct priority_queue children_queue;$/;" m struct:gomp_task typeref:struct:gomp_task::priority_queue +choose_pivot testsuite/libgomp.c/sort-1.c /^choose_pivot (int *array, int lo, int hi)$/;" f file: +chunk_size libgomp.h /^ long chunk_size;$/;" m struct:gomp_work_share::__anon46::__anon47 +chunk_size libgomp.h /^ long chunk_size;$/;" m union:gomp_doacross_work_share::__anon44 +chunk_size_ull libgomp.h /^ unsigned long long chunk_size_ull;$/;" m struct:gomp_work_share::__anon46::__anon48 +chunk_size_ull libgomp.h /^ unsigned long long chunk_size_ull;$/;" m union:gomp_doacross_work_share::__anon44 +chunksize testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer, parameter :: n = 100, n2 = 1000, chunksize /;" v program:reduction +clean_data testsuite/libgomp.c/loop-1.c /^static void clean_data (void)$/;" f file: +clean_data testsuite/libgomp.c/loop-2.c /^static void clean_data (void)$/;" f file: +clean_data testsuite/libgomp.c/ordered-1.c /^static void clean_data (void)$/;" f file: +clean_data testsuite/libgomp.c/ordered-2.c /^static void clean_data (void)$/;" f file: +clean_data testsuite/libgomp.c/sections-1.c /^static void clean_data (void)$/;" f file: +clear testsuite/libgomp.c++/ctor-11.C /^ static void clear () { icount = ccount = dcount = xcount = 0; }$/;" f struct:B +clear testsuite/libgomp.c++/ctor-13.C /^void B::clear()$/;" f class:B +clear testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^static void clear (int *ary, int size)$/;" f file: +clear testsuite/libgomp.oacc-c-c++-common/tile-1.c /^static void clear (int *ary, int size)$/;" f file: +clear_transitive_edges tdg.c /^int clear_transitive_edges (struct gomp_task *task)$/;" f +clock testsuite/libgomp.oacc-c-c++-common/subr.h /^static int clock (void)$/;" f +clock_khz plugin/plugin-nvptx.c /^ int clock_khz;$/;" m struct:ptx_device file: +close_enough testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^int close_enough (Type a, Type b)$/;" f +close_enough testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^int close_enough (Type a, Type b)$/;" f +close_enough testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^int close_enough (Type a, Type b)$/;" f +close_enough testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^int close_enough (Type a, Type b)$/;" f +cmask testsuite/libgomp.c++/ctor-10.C /^static unsigned cmask[THR];$/;" v file: +cmask testsuite/libgomp.c++/ctor-8.C /^static unsigned cmask[THR];$/;" v file: +cmask testsuite/libgomp.c++/ctor-9.C /^static unsigned cmask[THR];$/;" v file: +cnt tdg.h /^ signed char cnt; \/\/ Number of dependent tasks:$/;" m struct:gomp_tdg_node +cnt testsuite/libgomp.c++/atomic-12.C /^int x = 6, cnt;$/;" v +cnt testsuite/libgomp.c++/atomic-13.C /^int cnt;$/;" v +cnt testsuite/libgomp.c++/atomic-8.C /^int x = 6, cnt;$/;" v +cnt testsuite/libgomp.c++/atomic-9.C /^int cnt;$/;" v +cnt testsuite/libgomp.c++/for-6.C /^int cnt;$/;" v +cnt testsuite/libgomp.c++/for-7.C /^int cnt;$/;" v +cnt testsuite/libgomp.c/atomic-14.c /^int x = 6, cnt;$/;" v +cnt testsuite/libgomp.c/atomic-16.c /^int x = 6, cnt;$/;" v +cnt testsuite/libgomp.c/nqueens-1.c /^int cnt;$/;" v +cnt testsuite/libgomp.c/ordered-3.c /^int cnt;$/;" v +cnt testsuite/libgomp.c/pr29947-1.c /^int cnt;$/;" v +cnt testsuite/libgomp.c/pr29947-2.c /^int cnt;$/;" v +cnt testsuite/libgomp.fortran/reduction1.f90 /^ integer :: i, ia (6), n, cnt$/;" v +cnt testsuite/libgomp.fortran/reduction2.f90 /^ integer :: n, cnt$/;" v +cnt testsuite/libgomp.fortran/reduction3.f90 /^ integer (kind = 4) :: i, ia (6), n, cnt$/;" v +cnt testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j, ja (6), k, ka (6), ta (6), n, cnt,/;" v +cnt testsuite/libgomp.fortran/taskloop4.f90 /^ integer :: min_iters, max_iters, ntasks, cnt$/;" v +code plugin/plugin-nvptx.c /^ const char *code;$/;" m struct:targ_ptx_obj file: +collapse1 testsuite/libgomp.fortran/collapse1.f90 /^program collapse1$/;" p +collapse1 testsuite/libgomp.oacc-fortran/collapse-1.f90 /^program collapse1$/;" p +collapse2 testsuite/libgomp.fortran/collapse2.f90 /^program collapse2$/;" p +collapse2 testsuite/libgomp.oacc-fortran/collapse-2.f90 /^program collapse2$/;" p +collapse2 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^program collapse2$/;" p +collapse3 testsuite/libgomp.fortran/collapse3.f90 /^program collapse3$/;" p +collapse3 testsuite/libgomp.oacc-fortran/collapse-3.f90 /^program collapse3$/;" p +collapse3 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^program collapse3$/;" p +collapse4 testsuite/libgomp.oacc-fortran/collapse-4.f90 /^program collapse4$/;" p +collapse5 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^program collapse5$/;" p +collapse6 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^program collapse6$/;" p +collapse7 testsuite/libgomp.oacc-fortran/collapse-7.f90 /^program collapse7$/;" p +collapse8 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^program collapse8$/;" p +cols testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ integer :: cols,/;" v program:e_51_3 +combiner1 testsuite/libgomp.fortran/udr9.f90 /^ elemental subroutine combiner1 /;" s module:udr9m1 +combiner2 testsuite/libgomp.fortran/udr9.f90 /^ subroutine combiner2 /;" s module:udr9m2 +command_q plugin/plugin-hsa.c /^ hsa_queue_t *command_q;$/;" m struct:agent_info file: +concur plugin/plugin-nvptx.c /^ bool concur;$/;" m struct:ptx_device file: +concurrent testsuite/libgomp.c/depend-1.c /^concurrent (void)$/;" f +concurrent testsuite/libgomp.fortran/depend-1.f90 /^ subroutine concurrent$/;" s +concurrent2 testsuite/libgomp.c/depend-1.c /^concurrent2 (void)$/;" f +concurrent2 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine concurrent2$/;" s +concurrent3 testsuite/libgomp.c/depend-1.c /^concurrent3 (void)$/;" f +concurrent3 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine concurrent3$/;" s +cond config/posix/sem.h /^ pthread_cond_t cond;$/;" m struct:gomp_sem +condinc1 testsuite/libgomp.fortran/condinc1.f /^ program condinc1$/;" p +condinc2 testsuite/libgomp.fortran/condinc2.f /^ program condinc2$/;" p +condinc3 testsuite/libgomp.fortran/condinc3.f90 /^program condinc3$/;" p +condinc4 testsuite/libgomp.fortran/condinc4.f90 /^ program condinc4$/;" p +const_iterator testsuite/libgomp.c++/for-3.C /^ typedef typename std::vector::const_iterator const_iterator;$/;" t class:J file: +const_iterator testsuite/libgomp.c++/taskloop-7.C /^ typedef typename std::vector::const_iterator const_iterator;$/;" t class:J file: +context_check testsuite/libgomp.oacc-c-c++-common/context-1.c /^context_check (CUcontext ctx1)$/;" f +context_check testsuite/libgomp.oacc-c-c++-common/context-2.c /^context_check (CUcontext ctx1)$/;" f +context_check testsuite/libgomp.oacc-c-c++-common/context-3.c /^context_check (CUcontext ctx1)$/;" f +context_check testsuite/libgomp.oacc-c-c++-common/context-4.c /^context_check (CUcontext ctx1)$/;" f +contig_cpucount testsuite/libgomp.c/affinity-1.c /^unsigned long contig_cpucount;$/;" v +control_directives_mask plugin/hsa_ext_finalize.h /^ uint64_t control_directives_mask;$/;" m struct:hsa_ext_control_directives_s +coord testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c /^static int __attribute__ ((noinline)) coord ()$/;" f file: +coordinate_mode plugin/hsa_ext_finalize.h /^ hsa_ext_sampler_coordinate_mode_t coordinate_mode;$/;" m struct:hsa_ext_sampler_descriptor_s +copy_ctors_done libgomp.h /^ bool copy_ctors_done;$/;" m struct:gomp_task +copy_firstprivate_data target.c /^copy_firstprivate_data (char *tgt, size_t mapnum, void **hostaddrs,$/;" f file: +copy_from libgomp.h /^ bool copy_from;$/;" m struct:target_var_desc +copyctors testsuite/libgomp.c++/ctor-12.C /^ static int ctors, dtors, copyctors, assignops;$/;" m struct:A file: +copyctors testsuite/libgomp.c++/ctor-12.C /^int A::copyctors;$/;" m class:A file: +copyprivate libgomp.h /^ void *copyprivate;$/;" m union:gomp_work_share::__anon50 +count config/linux/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon40 +count config/linux/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" m struct:__anon41 +count config/nvptx/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon36 +count config/nvptx/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" m struct:__anon37 +count config/nvptx/simple-bar.h /^ unsigned count;$/;" m struct:__anon38 +count config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon31 +count config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; } omp_nest_lock_25_t;$/;" m struct:__anon30 +count config/posix/omp-lock.h /^typedef struct { sem_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon32 +count testsuite/libgomp.c++/ctor-5.C /^ static int count;$/;" m struct:B file: +count testsuite/libgomp.c++/ctor-5.C /^int B::count;$/;" m class:B file: +count testsuite/libgomp.c++/ctor-6.C /^ static int count;$/;" m struct:B file: +count testsuite/libgomp.c++/ctor-6.C /^int B::count;$/;" m class:B file: +count testsuite/libgomp.c++/loop-6.C /^volatile int count;$/;" v +count testsuite/libgomp.c/affinity-1.c /^ int count;$/;" m struct:places file: +count testsuite/libgomp.c/loop-16.c /^volatile int count;$/;" v +count testsuite/libgomp.c/loop-3.c /^volatile int count;$/;" v +count_avail_process_cpus config/mingw32/proc.c /^count_avail_process_cpus ()$/;" f file: +count_gpu_agents plugin/plugin-hsa.c /^count_gpu_agents (hsa_agent_t agent, void *data __attribute__ ((unused)))$/;" f file: +cpu_relax config/linux/alpha/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/ia64/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/mips/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/powerpc/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/s390/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/sparc/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/tile/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/linux/x86/futex.h /^cpu_relax (void)$/;" f +cpu_relax config/nvptx/doacross.h /^cpu_relax (void)$/;" f +cpu_relax config/posix/doacross.h /^cpu_relax (void)$/;" f +cr testsuite/libgomp.c++/target-2.C /^double *&cr = c;$/;" v +create_and_finalize_hsa_program plugin/plugin-hsa.c /^create_and_finalize_hsa_program (struct agent_info *agent)$/;" f file: +create_kernel_dispatch plugin/plugin-hsa.c /^create_kernel_dispatch (struct kernel_info *kernel, unsigned omp_data_size)$/;" f file: +create_lock_lock critical.c /^static gomp_mutex_t create_lock_lock;$/;" v file: +create_single_kernel_dispatch plugin/plugin-hsa.c /^create_single_kernel_dispatch (struct kernel_info *kernel,$/;" f file: +create_thread_data_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_create_thread_data) *create_thread_data_func;$/;" m struct:acc_dispatch_t +cs testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsum, gs, ws, vs, cs,/;" v program:reduction +cs testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ integer :: i, j, vsum, cs,/;" v program:reduction +cs1 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1, vs2, cs1,/;" v program:reduction +cs2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1, vs2, cs1, cs2,/;" v program:reduction +ctor testsuite/libgomp.c++/pr30703.C /^int ctor, cctor, dtor;$/;" v +ctors testsuite/libgomp.c++/ctor-12.C /^ static int ctors, dtors, copyctors, assignops;$/;" m struct:A file: +ctors testsuite/libgomp.c++/ctor-12.C /^int A::ctors;$/;" m class:A file: +ctx plugin/plugin-nvptx.c /^ CUcontext ctx;$/;" m struct:ptx_device file: +ctx_shared plugin/plugin-nvptx.c /^ bool ctx_shared;$/;" m struct:ptx_device file: +cuCtxCreate plugin/cuda/cuda.h 111;" d +cuCtxDestroy plugin/cuda/cuda.h 113;" d +cuCtxPopCurrent plugin/cuda/cuda.h 117;" d +cuCtxPushCurrent plugin/cuda/cuda.h 119;" d +cuEventDestroy plugin/cuda/cuda.h 126;" d +cuLinkAddData plugin/cuda/cuda.h 137;" d +cuLinkCreate plugin/cuda/cuda.h 141;" d +cuMemAlloc plugin/cuda/cuda.h 144;" d +cuMemAllocHost plugin/cuda/cuda.h 146;" d +cuMemFree plugin/cuda/cuda.h 159;" d +cuMemGetAddressRange plugin/cuda/cuda.h 162;" d +cuMemHostGetDevicePointer plugin/cuda/cuda.h 164;" d +cuMemcpyDtoDAsync plugin/cuda/cuda.h 149;" d +cuMemcpyDtoH plugin/cuda/cuda.h 151;" d +cuMemcpyDtoHAsync plugin/cuda/cuda.h 153;" d +cuMemcpyHtoD plugin/cuda/cuda.h 155;" d +cuMemcpyHtoDAsync plugin/cuda/cuda.h 157;" d +cuModuleGetGlobal plugin/cuda/cuda.h 167;" d +cuStreamDestroy plugin/cuda/cuda.h 173;" d +cuda libgomp.h /^ } cuda;$/;" m struct:acc_dispatch_t typeref:struct:acc_dispatch_t::__anon52 +cuda_error plugin/plugin-nvptx.c /^cuda_error (CUresult r)$/;" f file: +cuda_lib plugin/plugin-nvptx.c /^} cuda_lib;$/;" v typeref:struct:cuda_lib_s +cuda_lib_inited plugin/plugin-nvptx.c /^static signed char cuda_lib_inited = -1;$/;" v file: +cuda_lib_s plugin/plugin-nvptx.c /^struct cuda_lib_s {$/;" s file: +curr_tdg_g tdg.c /^int curr_tdg_g = -1; \/\/ index on current tdg$/;" v +current_stream plugin/plugin-nvptx.c /^ struct ptx_stream *current_stream;$/;" m struct:nvptx_thread typeref:struct:nvptx_thread::ptx_stream file: +d plugin/plugin-nvptx.c /^ CUdeviceptr d;$/;" m struct:ptx_stream file: +d testsuite/libgomp.c++/member-2.C /^int c, d, e;$/;" v +d testsuite/libgomp.c++/member-3.C /^int d[64];$/;" v +d testsuite/libgomp.c++/member-4.C /^int c, d, e;$/;" v +d testsuite/libgomp.c++/member-5.C /^int d[64];$/;" v +d testsuite/libgomp.c++/member-7.C /^int c, d, e;$/;" v +d testsuite/libgomp.c++/target-11.C /^struct T { int a; int *b; int c; char (&d)[10]; };$/;" m struct:T file: +d testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +d testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +d testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +d testsuite/libgomp.c++/target-20.C /^struct S { int a, b, c, d; };$/;" m struct:S file: +d testsuite/libgomp.c++/udr-6.C /^struct D { int d; D () : d (3) {} };$/;" m struct:D file: +d testsuite/libgomp.c/atomic-1.c /^double d;$/;" v +d testsuite/libgomp.c/atomic-2.c /^double d = 1.5;$/;" v +d testsuite/libgomp.c/atomic-3.c /^_Complex double d, f;$/;" v +d testsuite/libgomp.c/atomic-6.c /^union { unsigned long long l; double d; } u = { .l = 0x7ff0000000072301ULL };$/;" m union:__anon26 file: +d testsuite/libgomp.c/autopar-1.c /^double d[1024], e[1024];$/;" v +d testsuite/libgomp.c/doacross-1.c /^volatile int d, e;$/;" v +d testsuite/libgomp.c/doacross-2.c /^volatile int d, e;$/;" v +d testsuite/libgomp.c/doacross-3.c /^volatile int d, e;$/;" v +d testsuite/libgomp.c/pr26943-2.c /^int a = 8, b = 12, c = 16, d = 20, j = 0;$/;" v +d testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +d testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +d testsuite/libgomp.c/pr46886.c /^int d[1024], e[1024];$/;" v +d testsuite/libgomp.c/pr58392.c /^int d[32 * 32];$/;" v +d testsuite/libgomp.c/pr58756.c /^int d[32 * 32];$/;" v +d testsuite/libgomp.c/pr64868.c /^double d = 4.0;$/;" v +d testsuite/libgomp.c/reduction-15.c /^int a[16], b[16], c[16], d[5][2];$/;" v +d testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +d testsuite/libgomp.c/target-31.c /^int a = 1, b = 2, c = 3, d = 4;$/;" v +d testsuite/libgomp.c/target-link-1.c /^struct S d = { 8888, 8888 };$/;" v typeref:struct:S +d testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integer :: d,/;" k type:dl +d testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integer :: d,/;" k type:dl +d testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integer :: d,/;" k type:dl +d testsuite/libgomp.fortran/allocatable6.f90 /^ integer, allocatable :: a(:), b(:), c(:), d(/;" v +d testsuite/libgomp.fortran/crayptr2.f90 /^ integer :: a, b, c, d,/;" v +d testsuite/libgomp.fortran/declare-simd-1.f90 /^ real :: b(128), d(/;" v +d testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^ real :: accum, accum_ref, d$/;" v program:e_53_5 +d testsuite/libgomp.fortran/examples-4/device-1.f90 /^ logical :: c, d$/;" v program:e_57_1 +d testsuite/libgomp.fortran/examples-4/teams-2.f90 /^ real :: ref, d$/;" v program:e_54_1 +d testsuite/libgomp.fortran/examples-4/teams-3.f90 /^ real :: ref, d$/;" v program:e_54_3 +d testsuite/libgomp.fortran/examples-4/teams-4.f90 /^ real :: ref, d$/;" v program:e_54_4 +d testsuite/libgomp.fortran/lib1.f90 /^ do/;" v +d testsuite/libgomp.fortran/omp_atomic1.f90 /^ do/;" v +d testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer, di/;" v +d testsuite/libgomp.fortran/omp_atomic3.f90 /^ do/;" v +d testsuite/libgomp.fortran/omp_atomic4.f90 /^ do/;" v +d testsuite/libgomp.fortran/omp_atomic5.f90 /^ do/;" v +d testsuite/libgomp.fortran/pointer1.f90 /^ integer, target :: b, d(/;" v +d testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d,/;" v +d testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d,/;" v +d testsuite/libgomp.fortran/reduction1.f90 /^ do/;" v +d testsuite/libgomp.fortran/reduction3.f90 /^ do/;" v +d testsuite/libgomp.fortran/reference1.f90 /^ do/;" v +d testsuite/libgomp.fortran/simd7.f90 /^ integer :: d(/;" v +d testsuite/libgomp.fortran/target2.f90 /^ integer :: a, b(2:n-1), c(n), d(/;" v +d testsuite/libgomp.fortran/threadprivate1.f90 /^ do/;" v module:threadprivate1 +d testsuite/libgomp.fortran/udr1.f90 /^ type (dt/;" v +d testsuite/libgomp.fortran/udr15.f90 /^ type(dt/;" v +d testsuite/libgomp.fortran/udr2.f90 /^ type (dt/;" v +d testsuite/libgomp.fortran/udr3.f90 /^ character(kind=/;" v +d testsuite/libgomp.fortran/udr4.f90 /^ character(kind=/;" v +d testsuite/libgomp.fortran/udr8.f90 /^ type(dt/;" v +d testsuite/libgomp.fortran/udr9.f90 /^ type(dt/;" v +d testsuite/libgomp.fortran/vla7.f90 /^ character (6) :: d(/;" v +d testsuite/libgomp.oacc-c-c++-common/declare-1.c /^int d[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };$/;" v +d testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ real, allocatable :: a(:), b(:), c(:), d(/;" v program:asyncwait +d testsuite/libgomp.oacc-fortran/data-3.f90 /^ real, allocatable :: a(:), b(:), c(:), d(/;" v program:asyncwait +d testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ real, allocatable :: a(:), b(:), c(:), d(/;" v program:asyncwait +d testsuite/libgomp.oacc-fortran/data-4.f90 /^ real, allocatable :: a(:), b(:), c(:), d(/;" v program:asyncwait +d testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer :: d(/;" v program:main +d testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ integer :: a, b(Nupper), c, d,/;" v program:firstprivate +d1 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2, d1,/;" v +d1 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2, d1,/;" v +d2 testsuite/libgomp.fortran/omp_atomic3.f90 /^ double precision :: d, d2,/;" v +d2 testsuite/libgomp.fortran/omp_atomic4.f90 /^ double precision :: d, d2,/;" v +d2 testsuite/libgomp.fortran/omp_atomic5.f90 /^ double precision :: d, d2,/;" v +d2 testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2, d1, d2$/;" v +d2 testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(1024), a, b, c, d, e, a1, b1, a2, b2, d1, d2$/;" v +d_x testsuite/libgomp.oacc-c-c++-common/lib-88.c /^void *d_x;$/;" v +d_x testsuite/libgomp.oacc-c-c++-common/lib-89.c /^void **d_x;$/;" v +d_x testsuite/libgomp.oacc-c-c++-common/lib-90.c /^void **d_x;$/;" v +d_x testsuite/libgomp.oacc-c-c++-common/lib-92.c /^void **d_x;$/;" v +da testsuite/libgomp.fortran/reduction1.f90 /^ double precision :: d, da /;" v +da testsuite/libgomp.fortran/reduction3.f90 /^ double precision :: d, da /;" v +data libgomp.h /^ void *data;$/;" m struct:gomp_thread +data tdg.h /^ void* data; \/\/ Data structure containing the parameters to be passed to the task outlined function$/;" m struct:gomp_tdg_node +data testsuite/libgomp.c/loop-1.c /^static int data[N];$/;" v file: +data testsuite/libgomp.c/loop-2.c /^static int data[N][2];$/;" v file: +data testsuite/libgomp.c/ordered-1.c /^static int data[N];$/;" v file: +data testsuite/libgomp.c/sections-1.c /^static int data[N];$/;" v file: +data_environ libgomp.h /^ struct target_mem_desc *data_environ;$/;" m struct:acc_dispatch_t typeref:struct:acc_dispatch_t::target_mem_desc +data_to_free tdg.h /^struct data_to_free {$/;" s +dblinit testsuite/libgomp.c++/udr-3.C /^ static void dblinit (D *x) { *x = 3.0; }$/;" f struct:V +dblinit testsuite/libgomp.c++/udr-3.C /^dblinit (double *p)$/;" f +dc testsuite/libgomp.c++/ctor-13.C /^ static int ic, dc, xc, ac, cc;$/;" m struct:B file: +dc testsuite/libgomp.c++/ctor-13.C /^int B::dc;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-1.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-1.C /^int B::dcount;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-11.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-11.C /^int B::dcount;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-2.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-2.C /^int B::dcount;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-3.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-3.C /^int B::dcount;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-4.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-4.C /^int B::dcount;$/;" m class:B file: +dcount testsuite/libgomp.c++/ctor-7.C /^ static int dcount;$/;" m struct:B file: +dcount testsuite/libgomp.c++/ctor-7.C /^int B::dcount;$/;" m class:B file: +debug plugin/plugin-hsa.c /^ uint64_t debug;$/;" m struct:GOMP_hsa_kernel_dispatch file: +debug plugin/plugin-hsa.c /^static bool debug;$/;" v file: +declare_simd_1_mod testsuite/libgomp.fortran/declare-simd-1.f90 /^module declare_simd_1_mod$/;" m +declare_simd_2_mod testsuite/libgomp.fortran/declare-simd-2.f90 /^module declare_simd_2_mod$/;" m +declare_target_1_mod testsuite/libgomp.fortran/declare-target-1.f90 /^module declare_target_1_mod$/;" m +default_device testsuite/libgomp.fortran/examples-4/device-3.f90 /^ integer :: default_device$/;" v program:e_57_3 +default_device_var libgomp.h /^ int default_device_var;$/;" m struct:gomp_task_icv +default_lock critical.c /^static gomp_mutex_t default_lock;$/;" v file: +delay testsuite/libgomp.oacc-c-c++-common/subr.h /^delay (unsigned long *d_o, unsigned long delay)$/;" f +delay2 testsuite/libgomp.oacc-c-c++-common/subr.h /^delay2 (unsigned long *d_o, unsigned long delay, unsigned long tid)$/;" f +delete_copyout oacc-mem.c /^delete_copyout (unsigned f, void *h, size_t s, const char *libfnname)$/;" f file: +dep testsuite/libgomp.c/depend-1.c /^dep (void)$/;" f +dep testsuite/libgomp.fortran/depend-1.f90 /^ subroutine dep$/;" s +dep2 testsuite/libgomp.c/depend-1.c /^dep2 (void)$/;" f +dep2 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine dep2$/;" s +dep3 testsuite/libgomp.c/depend-1.c /^dep3 (void)$/;" f +dep3 testsuite/libgomp.fortran/depend-1.f90 /^ subroutine dep3$/;" s +depend libgomp.h /^ struct gomp_task_depend_entry depend[];$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_task_depend_entry +depend_count libgomp.h /^ size_t depend_count;$/;" m struct:gomp_task +depend_hash libgomp.h /^ struct htab *depend_hash;$/;" m struct:gomp_task typeref:struct:gomp_task::htab +depend_hash_g tdg.c /^struct htab *depend_hash_g = NULL; \/\/ hash table handling dependency information for dynamic TDG$/;" v typeref:struct:htab +dependencies plugin/plugin-hsa.c /^ const char **dependencies;$/;" m struct:kernel_info file: +dependencies_count plugin/plugin-hsa.c /^ unsigned dependencies_count;$/;" m struct:kernel_info file: +dependers libgomp.h /^ struct gomp_dependers_vec *dependers;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_dependers_vec +depth plugin/hsa_ext_finalize.h /^ size_t depth;$/;" m struct:hsa_ext_image_descriptor_s +destroy_hsa_program plugin/plugin-hsa.c /^destroy_hsa_program (struct agent_info *agent)$/;" f file: +destroy_module plugin/plugin-hsa.c /^destroy_module (struct module_info *module)$/;" f file: +destroy_thread_data_func libgomp.h /^ *destroy_thread_data_func;$/;" m struct:acc_dispatch_t +detect_exceptions_mask plugin/hsa_ext_finalize.h /^ uint16_t detect_exceptions_mask;$/;" m struct:hsa_ext_control_directives_s +dev oacc-int.h /^ struct gomp_device_descr *dev;$/;" m struct:goacc_thread typeref:struct:goacc_thread::gomp_device_descr +dev plugin/plugin-nvptx.c /^ CUdevice dev;$/;" m struct:ptx_device file: +dev2dev_func libgomp.h /^ __typeof (GOMP_OFFLOAD_dev2dev) *dev2dev_func;$/;" m struct:gomp_device_descr +dev2host_func libgomp.h /^ __typeof (GOMP_OFFLOAD_dev2host) *dev2host_func;$/;" m struct:gomp_device_descr +device plugin/plugin-hsa.c /^ int device;$/;" m struct:async_run_info file: +device_descr libgomp.h /^ struct gomp_device_descr *device_descr;$/;" m struct:target_mem_desc typeref:struct:target_mem_desc::gomp_device_descr +device_run plugin/plugin-nvptx.c /^void (*device_run) (int n, void *fn_ptr, void *vars) = NULL;$/;" v +devicep libgomp.h /^ struct gomp_device_descr *devicep;$/;" m struct:gomp_target_task typeref:struct:gomp_target_task::gomp_device_descr +devices target.c /^static struct gomp_device_descr *devices;$/;" v typeref:struct:gomp_device_descr file: +diff testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ double precision :: a(128), b(128), sum, sum_ref, diff$/;" v program:SIMD3 +diff testsuite/libgomp.fortran/examples-4/simd-8.f90 /^ real :: pri, arr(1000), diff$/;" v program:simd_8f +difference_type testsuite/libgomp.c++/collapse-2.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/doacross-1.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/for-1.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/for-5.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/for-8.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/member-5.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/taskloop-6.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +difference_type testsuite/libgomp.c++/taskloop-9.C /^ typedef ptrdiff_t difference_type;$/;" t class:I file: +dim plugin/plugin-nvptx.c /^ unsigned short dim[GOMP_DIM_MAX];$/;" m struct:targ_fn_launch file: +dispatchers oacc-init.c /^static struct gomp_device_descr *dispatchers[_ACC_device_hwm] = { 0 };$/;" v typeref:struct:gomp_device_descr file: +distrib testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer, parameter :: distrib /;" v program:main +distrib testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer, parameter :: distrib /;" v program:main +dl testsuite/libgomp.fortran/alloc-comp-1.f90 /^ type dl$/;" t module:m +dl testsuite/libgomp.fortran/alloc-comp-2.f90 /^ type dl$/;" t module:m +dl testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type dl$/;" t module:m +dl testsuite/libgomp.fortran/associate2.f90 /^ type dl$/;" t program:associate2 +dmask testsuite/libgomp.c++/ctor-10.C /^static unsigned dmask[THR];$/;" v file: +dmask testsuite/libgomp.c++/ctor-8.C /^static unsigned dmask[THR];$/;" v file: +do_add testsuite/libgomp.fortran/udr5.f90 /^ function do_add(/;" f module:m +do_add testsuite/libgomp.fortran/udr6.f90 /^ elemental function do_add(/;" f module:m +do_by_16 testsuite/libgomp.c/appendix-a/a.36.1.c /^do_by_16 (float *x, int iam, int ipoints)$/;" f +do_some_work testsuite/libgomp.c++/cancel-parallel-3.C /^do_some_work (void)$/;" f file: +do_some_work testsuite/libgomp.c/cancel-parallel-3.c /^do_some_work (void)$/;" f file: +do_some_work testsuite/libgomp.fortran/cancel-parallel-3.f90 /^ subroutine do_some_work$/;" s +do_spin config/linux/wait.h /^static inline int do_spin (int *addr, int val)$/;" f +do_spin config/rtems/bar.c /^do_spin (int *addr, int val)$/;" f file: +do_test testsuite/libgomp.c/atomic-5.c /^do_test (void)$/;" f +do_test testsuite/libgomp.c/atomic-6.c /^do_test (void)$/;" f +do_wait config/linux/wait.h /^static inline void do_wait (int *addr, int val)$/;" f +do_wait config/rtems/bar.c /^do_wait (int *addr, int val)$/;" f file: +do_work testsuite/libgomp.c/examples-4/simd-8.c /^float do_work(float *arr)$/;" f +do_work testsuite/libgomp.fortran/examples-4/simd-8.f90 /^function do_work(/;" f module:work +doacross libgomp.h /^ struct gomp_doacross_work_share *doacross;$/;" m union:gomp_work_share::__anon49 typeref:struct:gomp_work_share::__anon49::gomp_doacross_work_share +doacross_spin config/linux/doacross.h /^static inline void doacross_spin (unsigned long *addr, unsigned long expected,$/;" f +doacross_spin config/nvptx/doacross.h /^static inline void doacross_spin (unsigned long *addr, unsigned long expected,$/;" f +doacross_spin config/posix/doacross.h /^static inline void doacross_spin (unsigned long *addr, unsigned long expected,$/;" f +doit testsuite/libgomp.c++/ctor-1.C /^void B::doit()$/;" f class:B +doit testsuite/libgomp.c++/ctor-11.C /^B::doit ()$/;" f class:B +doit testsuite/libgomp.c++/ctor-13.C /^void B::doit()$/;" f class:B +doit testsuite/libgomp.c++/ctor-2.C /^void B::doit()$/;" f class:B +doit testsuite/libgomp.c++/ctor-3.C /^void B::doit()$/;" f class:B +doit testsuite/libgomp.c++/ctor-4.C /^void B::doit()$/;" f class:B +doit testsuite/libgomp.c++/ctor-7.C /^void B::doit()$/;" f class:B +dotprod testsuite/libgomp.c/examples-4/teams-2.c /^float dotprod (float B[], float C[], int n, int block_size,$/;" f +dotprod testsuite/libgomp.c/examples-4/teams-3.c /^float dotprod (float B[], float C[], int n)$/;" f +dotprod testsuite/libgomp.c/examples-4/teams-4.c /^float dotprod (float B[], float C[], int n)$/;" f +dotprod testsuite/libgomp.c/omp_orphan.c /^float dotprod ()$/;" f +dotprod testsuite/libgomp.fortran/examples-4/teams-2.f90 /^function dotprod /;" f +dotprod testsuite/libgomp.fortran/examples-4/teams-3.f90 /^function dotprod /;" f +dotprod testsuite/libgomp.fortran/examples-4/teams-4.f90 /^function dotprod /;" f +dotprod_ref testsuite/libgomp.c/examples-4/teams-2.c /^float dotprod_ref (float B[], float C[], int n)$/;" f +dotprod_ref testsuite/libgomp.c/examples-4/teams-3.c /^float dotprod_ref (float B[], float C[], int n)$/;" f +dotprod_ref testsuite/libgomp.c/examples-4/teams-4.c /^float dotprod_ref (float B[], float C[], int n)$/;" f +dotprod_ref testsuite/libgomp.fortran/examples-4/teams-2.f90 /^function dotprod_ref /;" f +dotprod_ref testsuite/libgomp.fortran/examples-4/teams-3.f90 /^function dotprod_ref /;" f +dotprod_ref testsuite/libgomp.fortran/examples-4/teams-4.f90 /^function dotprod_ref /;" f +dp testsuite/libgomp.fortran/udr5.f90 /^ double precision :: dp$/;" v program:udr5 +dp testsuite/libgomp.fortran/udr6.f90 /^ double precision, allocatable :: dp(/;" v program:udr6 +dp_add testsuite/libgomp.fortran/udr5.f90 /^ subroutine dp_add(/;" s module:m +dp_add testsuite/libgomp.fortran/udr6.f90 /^ elemental subroutine dp_add(/;" s module:m +dp_init testsuite/libgomp.fortran/udr5.f90 /^ subroutine dp_init(/;" s module:m +dp_init testsuite/libgomp.fortran/udr6.f90 /^ elemental subroutine dp_init(/;" s module:m +driver testsuite/libgomp.fortran/jacobi.f /^ subroutine driver /;" s +dt testsuite/libgomp.fortran/alloc-comp-1.f90 /^ type dt$/;" t module:m +dt testsuite/libgomp.fortran/alloc-comp-2.f90 /^ type dt$/;" t module:m +dt testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type dt$/;" t module:m +dt testsuite/libgomp.fortran/associate2.f90 /^ type dt$/;" t program:associate2 +dt testsuite/libgomp.fortran/simd1.f90 /^ type dt$/;" t +dt testsuite/libgomp.fortran/udr1.f90 /^ type dt$/;" t module:udr1 +dt testsuite/libgomp.fortran/udr10.f90 /^ type dt$/;" t module:udr10m +dt testsuite/libgomp.fortran/udr11.f90 /^ type dt$/;" t module:udr11 +dt testsuite/libgomp.fortran/udr14.f90 /^ type dt$/;" t +dt testsuite/libgomp.fortran/udr15.f90 /^ type dt$/;" t module:udr15m2 +dt testsuite/libgomp.fortran/udr2.f90 /^ type dt$/;" t module:udr2 +dt testsuite/libgomp.fortran/udr5.f90 /^ type dt$/;" t module:m +dt testsuite/libgomp.fortran/udr6.f90 /^ type dt$/;" t module:m +dt testsuite/libgomp.fortran/udr8.f90 /^ type dt$/;" t module:udr8m2 +dt testsuite/libgomp.fortran/udr9.f90 /^ type dt$/;" t module:udr9m2 +dtor testsuite/libgomp.c++/pr30703.C /^int ctor, cctor, dtor;$/;" v +dtors testsuite/libgomp.c++/ctor-12.C /^ static int ctors, dtors, copyctors, assignops;$/;" m struct:A file: +dtors testsuite/libgomp.c++/ctor-12.C /^int A::dtors;$/;" m class:A file: +dyn_var libgomp.h /^ bool dyn_var;$/;" m struct:gomp_task_icv +e testsuite/libgomp.c++/collapse-2.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-1.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-2.C /^ T b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-3.C /^ const_iterator b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-4.C /^ iterator b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-5.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c++/for-8.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c++/member-2.C /^int c, d, e;$/;" v +e testsuite/libgomp.c++/member-4.C /^int c, d, e;$/;" v +e testsuite/libgomp.c++/member-7.C /^int c, d, e;$/;" v +e testsuite/libgomp.c++/pr38650.C /^int e;$/;" v +e testsuite/libgomp.c++/pr66702-1.C /^volatile int e = 5;$/;" v +e testsuite/libgomp.c++/pr69393.C /^int e = 5;$/;" v +e testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +e testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +e testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +e testsuite/libgomp.c++/task-1.C /^int e;$/;" v +e testsuite/libgomp.c++/task-3.C /^int e;$/;" v +e testsuite/libgomp.c++/task-4.C /^int e;$/;" v +e testsuite/libgomp.c++/task-5.C /^int e;$/;" v +e testsuite/libgomp.c++/task-6.C /^int e;$/;" v +e testsuite/libgomp.c++/taskloop-6.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c++/taskloop-7.C /^ const_iterator b, e;$/;" m class:J file: +e testsuite/libgomp.c++/taskloop-8.C /^ iterator b, e;$/;" m class:J file: +e testsuite/libgomp.c++/taskloop-9.C /^ I b, e;$/;" m class:J file: +e testsuite/libgomp.c/atomic-1.c /^ double e;$/;" m struct:__anon29 file: +e testsuite/libgomp.c/atomic-3.c /^short e[64];$/;" v +e testsuite/libgomp.c/autopar-1.c /^double d[1024], e[1024];$/;" v +e testsuite/libgomp.c/doacross-1.c /^volatile int d, e;$/;" v +e testsuite/libgomp.c/doacross-2.c /^volatile int d, e;$/;" v +e testsuite/libgomp.c/doacross-3.c /^volatile int d, e;$/;" v +e testsuite/libgomp.c/pr26943-2.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +e testsuite/libgomp.c/pr26943-3.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +e testsuite/libgomp.c/pr26943-4.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +e testsuite/libgomp.c/pr38650.c /^int e;$/;" v +e testsuite/libgomp.c/pr46886.c /^int d[1024], e[1024];$/;" v +e testsuite/libgomp.c/target-31.c /^int e[2] = { 5, 6 }, f[2] = { 7, 8 }, g[2] = { 9, 10 }, h[2] = { 11, 12 };$/;" v +e testsuite/libgomp.c/task-4.c /^int e;$/;" v +e testsuite/libgomp.c/taskloop-1.c /^int q, r, e;$/;" v +e testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integ/;" k type:dl +e testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integ/;" k type:dl +e testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integ/;" k type:dl +e testsuite/libgomp.fortran/lib1.f90 /^ double /;" v +e testsuite/libgomp.fortran/nested1.f90 /^ integ/;" v program:nested1 +e testsuite/libgomp.fortran/omp_atomic1.f90 /^ integ/;" v +e testsuite/libgomp.fortran/omp_atomic3.f90 /^ integ/;" v +e testsuite/libgomp.fortran/omp_atomic4.f90 /^ integ/;" v +e testsuite/libgomp.fortran/omp_atomic5.f90 /^ integ/;" v +e testsuite/libgomp.fortran/pr32550.f90 /^ integ/;" v +e testsuite/libgomp.fortran/pr66199-1.f90 /^ integ/;" v +e testsuite/libgomp.fortran/pr66199-2.f90 /^ integ/;" v +e testsuite/libgomp.fortran/pr81841.f90 /^ integ/;" v program:pr81841 +e testsuite/libgomp.fortran/simd7.f90 /^ integ/;" v +e testsuite/libgomp.fortran/target2.f90 /^ integ/;" v +e testsuite/libgomp.fortran/task4.f90 /^ integ/;" v +e testsuite/libgomp.fortran/taskloop1.f90 /^ logical :: e$/;" v +e testsuite/libgomp.fortran/udr3.f90 /^ character/;" v +e testsuite/libgomp.fortran/udr4.f90 /^ character/;" v +e testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ rea/;" v program:asyncwait +e testsuite/libgomp.oacc-fortran/data-3.f90 /^ rea/;" v program:asyncwait +e testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ rea/;" v program:asyncwait +e testsuite/libgomp.oacc-fortran/data-4.f90 /^ rea/;" v program:asyncwait +e testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ rea/;" v program:reduction_2 +e testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double /;" v program:reduction_3 +e1 testsuite/libgomp.fortran/nested1.f90 /^ integer :: e1,/;" v program:nested1 +e2 testsuite/libgomp.fortran/nested1.f90 /^ integer :: e1, e2,/;" v program:nested1 +e2 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2,/;" v +e2 testsuite/libgomp.fortran/retval1.f90 /^entry e2 /;" e function:f2 +e3 testsuite/libgomp.fortran/nested1.f90 /^ integer :: e1, e2, e3,/;" v program:nested1 +e3 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2, f3, e3,/;" v +e3 testsuite/libgomp.fortran/retval1.f90 /^entry e3 /;" e function:f3 +e4 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2, f3, e3, f4, e4,/;" v +e4 testsuite/libgomp.fortran/retval1.f90 /^entry e4 /;" e function:f4 +e5 testsuite/libgomp.fortran/retval1.f90 /^ integer :: e5$/;" v +e5 testsuite/libgomp.fortran/retval1.f90 /^entry e5 /;" e function:f5 +e_50_1 testsuite/libgomp.fortran/examples-4/target-1.f90 /^program e_50_1$/;" p +e_50_1_mod testsuite/libgomp.fortran/examples-4/target-1.f90 /^module e_50_1_mod$/;" m +e_50_2 testsuite/libgomp.fortran/examples-4/target-2.f90 /^program e_50_2$/;" p +e_50_2_mod testsuite/libgomp.fortran/examples-4/target-2.f90 /^module e_50_2_mod$/;" m +e_50_3 testsuite/libgomp.fortran/examples-4/target-3.f90 /^program e_50_3$/;" p +e_50_3_mod testsuite/libgomp.fortran/examples-4/target-3.f90 /^module e_50_3_mod$/;" m +e_50_4 testsuite/libgomp.fortran/examples-4/target-4.f90 /^program e_50_4$/;" p +e_50_4_mod testsuite/libgomp.fortran/examples-4/target-4.f90 /^module e_50_4_mod$/;" m +e_50_5 testsuite/libgomp.fortran/examples-4/target-5.f90 /^program e_50_5$/;" p +e_50_5_mod testsuite/libgomp.fortran/examples-4/target-5.f90 /^module e_50_5_mod$/;" m +e_51_1 testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^program e_51_1$/;" p +e_51_1_mod testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^module e_51_1_mod$/;" m +e_51_2 testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^program e_51_2$/;" p +e_51_2_mod testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^module e_51_2_mod$/;" m +e_51_3 testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^program e_51_3$/;" p +e_51_3_mod testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^module e_51_3_mod$/;" m +e_51_4 testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^program e_51_4$/;" p +e_51_4_mod testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^module e_51_4_mod$/;" m +e_51_5 testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^program e_51_5$/;" p +e_51_5_mod testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^module e_51_5_mod$/;" m +e_51_6 testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^program e_51_6$/;" p +e_51_6_mod testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^module e_51_6_mod$/;" m +e_51_7 testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^program e_51_7$/;" p +e_51_7_mod testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^module e_51_7_mod$/;" m +e_52_1 testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^program e_52_1$/;" p +e_52_1_mod testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^module e_52_1_mod$/;" m +e_52_2 testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^program e_52_2$/;" p +e_52_2_mod testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^module e_52_2_mod$/;" m +e_53_1 testsuite/libgomp.fortran/examples-4/declare_target-1.f90 /^program e_53_1$/;" p +e_53_1_mod testsuite/libgomp.fortran/examples-4/declare_target-1.f90 /^module e_53_1_mod$/;" m +e_53_2 testsuite/libgomp.fortran/examples-4/declare_target-2.f90 /^program e_53_2$/;" p +e_53_3 testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^program e_53_3$/;" p +e_53_3_mod testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^module e_53_3_mod$/;" m +e_53_4 testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^program e_53_4$/;" p +e_53_4_mod testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^module e_53_4_mod$/;" m +e_53_5 testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^program e_53_5$/;" p +e_53_5_mod testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^module e_53_5_mod$/;" m +e_54_1 testsuite/libgomp.fortran/examples-4/teams-2.f90 /^program e_54_1$/;" p +e_54_3 testsuite/libgomp.fortran/examples-4/teams-3.f90 /^program e_54_3$/;" p +e_54_4 testsuite/libgomp.fortran/examples-4/teams-4.f90 /^program e_54_4$/;" p +e_54_5 testsuite/libgomp.fortran/examples-4/teams-5.f90 /^program e_54_5$/;" p +e_54_5_mod testsuite/libgomp.fortran/examples-4/teams-5.f90 /^module e_54_5_mod$/;" m +e_54_6 testsuite/libgomp.fortran/examples-4/teams-6.f90 /^program e_54_6$/;" p +e_54_6_mod testsuite/libgomp.fortran/examples-4/teams-6.f90 /^module e_54_6_mod$/;" m +e_55_1 testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^program e_55_1$/;" p +e_55_1_mod testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^module e_55_1_mod$/;" m +e_55_2 testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^program e_55_2$/;" p +e_57_1 testsuite/libgomp.fortran/examples-4/device-1.f90 /^program e_57_1$/;" p +e_57_2 testsuite/libgomp.fortran/examples-4/device-2.f90 /^program e_57_2$/;" p +e_57_3 testsuite/libgomp.fortran/examples-4/device-3.f90 /^program e_57_3$/;" p +e_inner testsuite/libgomp.c++/ctor-3.C /^ static B *e_inner;$/;" m struct:B file: +e_inner testsuite/libgomp.c++/ctor-3.C /^B * B::e_inner;$/;" m class:B file: +e_inner testsuite/libgomp.c++/ctor-4.C /^ static B *e_inner;$/;" m struct:B file: +e_inner testsuite/libgomp.c++/ctor-4.C /^B * B::e_inner;$/;" m class:B file: +e_outer testsuite/libgomp.c++/ctor-3.C /^ static B *e_outer;$/;" m struct:B file: +e_outer testsuite/libgomp.c++/ctor-3.C /^B * B::e_outer;$/;" m class:B file: +e_outer testsuite/libgomp.c++/ctor-4.C /^ static B *e_outer;$/;" m struct:B file: +e_outer testsuite/libgomp.c++/ctor-4.C /^B * B::e_outer;$/;" m class:B file: +ecount testsuite/libgomp.c++/ctor-4.C /^ static int ecount;$/;" m struct:B file: +ecount testsuite/libgomp.c++/ctor-4.C /^int B::ecount;$/;" m class:B file: +elem libgomp.h /^ struct gomp_task *elem[];$/;" m struct:gomp_dependers_vec typeref:struct:gomp_dependers_vec::gomp_task +elements testsuite/libgomp.hsa.c/tiling-1.c /^ float* elements;$/;" m struct:__anon23 file: +elements testsuite/libgomp.hsa.c/tiling-2.c /^ float* elements;$/;" m struct:__anon22 file: +elt_sz libgomp.h /^ unsigned long elt_sz;$/;" m struct:gomp_doacross_work_share +end libgomp-plugin.h /^ uintptr_t end;$/;" m struct:addr_pair +end libgomp.h /^ long end;$/;" m struct:gomp_work_share::__anon46::__anon47 +end testsuite/libgomp.c++/collapse-2.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-1.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-2.C /^template T J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-3.C /^const typename std::vector::const_iterator &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-4.C /^const typename std::basic_string::iterator &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-5.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/for-8.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/taskloop-6.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/taskloop-7.C /^const typename std::vector::const_iterator &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/taskloop-8.C /^const typename std::basic_string::iterator &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.c++/taskloop-9.C /^template const I &J::end () { return e; }$/;" f class:J +end testsuite/libgomp.fortran/strassen.f90 /^ double precision :: start, end$/;" v program:strassen_matmul +end_ull libgomp.h /^ unsigned long long end_ull;$/;" m struct:gomp_work_share::__anon46::__anon48 +enter_data testsuite/libgomp.c/target-20.c /^void enter_data (int *X)$/;" f +entries hashtab.h /^ hash_entry_type entries[];$/;" m struct:htab +entries tdg.h /^ tdg_hash_entry *entries[];$/;" m struct:tdg_func_hash_table +err testsuite/libgomp.c/pr39591-1.c /^int err;$/;" v +err testsuite/libgomp.c/pr39591-2.c /^int err;$/;" v +err testsuite/libgomp.c/pr39591-3.c /^int err, a[40];$/;" v +err testsuite/libgomp.c/private-1.c /^int err;$/;" v +err testsuite/libgomp.c/task-1.c /^int err;$/;" v +err testsuite/libgomp.c/task-5.c /^int err;$/;" v +err testsuite/libgomp.fortran/pr48894.f90 /^ integer :: err$/;" v +err testsuite/libgomp.fortran/task2.f90 /^ integer :: err$/;" v +err testsuite/libgomp.fortran/task4.f90 /^ integer :: err,/;" v +error_check testsuite/libgomp.fortran/jacobi.f /^ subroutine error_check /;" s +errors testsuite/libgomp.c++/pr34513.C /^static int errors = 0;$/;" v file: +errors testsuite/libgomp.c/pr30494.c /^int errors;$/;" v +errors testsuite/libgomp.c/pr34513.c /^static int errors = 0;$/;" v file: +errval testsuite/libgomp.c++/task-8.C /^int errval;$/;" v +event_add plugin/plugin-nvptx.c /^event_add (enum ptx_event_type type, CUevent *e, void *h, int val)$/;" f file: +event_gc plugin/plugin-nvptx.c /^event_gc (bool memmap_lockable)$/;" f file: +evt plugin/plugin-nvptx.c /^ CUevent *evt;$/;" m struct:ptx_event file: +example testsuite/libgomp.fortran/examples-4/task_dep-1.f90 /^program example$/;" p +example testsuite/libgomp.fortran/examples-4/task_dep-2.f90 /^program example$/;" p +example testsuite/libgomp.fortran/examples-4/task_dep-3.f90 /^program example$/;" p +example testsuite/libgomp.fortran/examples-4/task_dep-4.f90 /^program example$/;" p +exec_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_exec) *exec_func;$/;" m struct:acc_dispatch_t +executable plugin/plugin-hsa.c /^ hsa_executable_t executable;$/;" m struct:agent_info file: +exit_data_0 testsuite/libgomp.c/target-20.c /^void exit_data_0 (int *D)$/;" f +exit_data_1 testsuite/libgomp.c/target-20.c /^void exit_data_1 ()$/;" f +exit_data_2 testsuite/libgomp.c/target-20.c /^void exit_data_2 (int *X)$/;" f +exit_data_3 testsuite/libgomp.c/target-20.c /^void exit_data_3 (int *p)$/;" f +exp testsuite/libgomp.oacc-fortran/if-1.f90 /^ real exp,/;" v program:main +exp2 testsuite/libgomp.oacc-fortran/if-1.f90 /^ real exp, exp2$/;" v program:main +expected testsuite/libgomp.c++/ctor-2.C /^ static B *expected;$/;" m struct:B file: +expected testsuite/libgomp.c++/ctor-2.C /^B * B::expected;$/;" m class:B file: +expected testsuite/libgomp.c++/ctor-5.C /^ static B *expected;$/;" m struct:B file: +expected testsuite/libgomp.c++/ctor-5.C /^B * B::expected;$/;" m class:B file: +expected testsuite/libgomp.c++/ctor-6.C /^ static B *expected;$/;" m struct:B file: +expected testsuite/libgomp.c++/ctor-6.C /^B * B::expected;$/;" m class:B file: +expx testsuite/libgomp.hsa.c/function-call-1.c /^expx (int x, int n)$/;" f +f testsuite/libgomp.c++/member-4.C /^int f[64];$/;" v +f testsuite/libgomp.c++/pr56217.C /^f ()$/;" f file: +f testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +f testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +f testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +f testsuite/libgomp.c++/target-2-aux.cc /^double f[1024];$/;" v +f testsuite/libgomp.c++/tls-init1.C /^A &f()$/;" f +f testsuite/libgomp.c/appendix-a/a.29.1.c /^f (int n, int B[n][n], int C[])$/;" f +f testsuite/libgomp.c/atomic-3.c /^_Complex double d, f;$/;" v +f testsuite/libgomp.c/autopar-1.c /^int f[1024], g[1024];$/;" v +f testsuite/libgomp.c/doacross-2.c /^volatile unsigned long long f;$/;" v +f testsuite/libgomp.c/doacross-3.c /^volatile unsigned long long f;$/;" v +f testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c /^f (void)$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt-3.c /^f (unsigned int n, unsigned int *__restrict__ a)$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt-4.c /^f (void)$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^f (unsigned int n, unsigned int *__restrict__ a, unsigned int *__restrict__ b,$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^f (int n, unsigned int *__restrict__ a, unsigned int *__restrict__ b,$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^f (int n, unsigned int *__restrict__ a, unsigned int *__restrict__ b,$/;" f +f testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^f (unsigned int n, unsigned int *__restrict__ a, unsigned int *__restrict__ b,$/;" f +f testsuite/libgomp.c/pr26943-2.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +f testsuite/libgomp.c/pr26943-3.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +f testsuite/libgomp.c/pr26943-4.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +f testsuite/libgomp.c/pr64868.c /^float f = 2.0f;$/;" v +f testsuite/libgomp.c/reduction-6.c /^float f;$/;" v +f testsuite/libgomp.c/target-31.c /^int e[2] = { 5, 6 }, f[2] = { 7, 8 }, g[2] = { 9, 10 }, h[2] = { 11, 12 };$/;" v +f testsuite/libgomp.fortran/alloc-comp-1.f90 /^ integer, allocatable :: f$/;" k type:dl +f testsuite/libgomp.fortran/alloc-comp-2.f90 /^ integer, allocatable :: f$/;" k type:dl +f testsuite/libgomp.fortran/alloc-comp-3.f90 /^ integer, allocatable :: f$/;" k type:dl +f testsuite/libgomp.fortran/associate3.f90 /^ real, allocatable :: f(/;" k type:t +f testsuite/libgomp.fortran/omp_atomic1.f90 /^ real :: c, f$/;" v +f testsuite/libgomp.fortran/omp_atomic3.f90 /^ real :: c, f$/;" v +f testsuite/libgomp.fortran/pr81841.f90 /^ real :: f(/;" v program:pr81841 +f testsuite/libgomp.fortran/simd7.f90 /^ integer :: d(2:18), e(3:n+1), f(/;" v +f testsuite/libgomp.fortran/target2.f90 /^ integer, pointer :: f,/;" v +f testsuite/libgomp.fortran/target3.f90 /^ integer, pointer :: f,/;" v +f testsuite/libgomp.fortran/udr3.f90 /^ character(kind = 1, len=1+1) :: f$/;" v +f testsuite/libgomp.fortran/udr4.f90 /^ character(kind = 1, len=1+1) :: f(/;" v +f0 testsuite/libgomp.c++/for-6.C /^f0 (T, int)$/;" f +f0 testsuite/libgomp.c++/for-6.C /^f0 (const char *, int type)$/;" f +f0 testsuite/libgomp.c++/for-6.C /^f0 (int, int type)$/;" f +f0 testsuite/libgomp.c++/for-7.C /^f0 (T, int)$/;" f +f0 testsuite/libgomp.c++/for-7.C /^f0 (const char *, int type)$/;" f +f0 testsuite/libgomp.c++/for-7.C /^f0 (int, int type)$/;" f +f0 testsuite/libgomp.c/for-2.h /^N(f0) (void)$/;" f +f0 testsuite/libgomp.c/loop-13.c /^f0 (void)$/;" f +f0 testsuite/libgomp.c/loop-14.c /^f0 (void)$/;" f +f0 testsuite/libgomp.c/loop-15.c /^f0 (void)$/;" f +f1 testsuite/libgomp.c++/collapse-2.C /^f1 (J x, J y, J z)$/;" f +f1 testsuite/libgomp.c++/ctor-13.C /^void f1(B &a)$/;" f +f1 testsuite/libgomp.c++/doacross-1.C /^f1 (const I &a, const I &b, const I &c, const I &d,$/;" f +f1 testsuite/libgomp.c++/for-1.C /^f1 (const I &x, const I &y)$/;" f +f1 testsuite/libgomp.c++/for-2.C /^f1 (int x, int y)$/;" f +f1 testsuite/libgomp.c++/for-3.C /^f1 (const std::vector::const_iterator &x,$/;" f +f1 testsuite/libgomp.c++/for-4.C /^f1 (const std::basic_string::iterator &x,$/;" f +f1 testsuite/libgomp.c++/for-5.C /^f1 (const I &x, const I &y)$/;" f +f1 testsuite/libgomp.c++/for-6.C /^f1 ()$/;" f +f1 testsuite/libgomp.c++/for-7.C /^f1 ()$/;" f +f1 testsuite/libgomp.c++/for-8.C /^f1 (const I &x, const I &y)$/;" f +f1 testsuite/libgomp.c++/linear-1.C /^f1 (int i)$/;" f +f1 testsuite/libgomp.c++/loop-5.C /^int f1() { check |= 1; return 1; }$/;" f +f1 testsuite/libgomp.c++/pr43893.C /^f1 ()$/;" f +f1 testsuite/libgomp.c++/pr69555-1.C /^f1 (int y)$/;" f +f1 testsuite/libgomp.c++/pr69555-2.C /^f1 (int y)$/;" f +f1 testsuite/libgomp.c++/task-1.C /^f1 (int i, int j, int k)$/;" f +f1 testsuite/libgomp.c++/task-6.C /^f1 (T i, T j, T k)$/;" f +f1 testsuite/libgomp.c++/taskloop-6.C /^f1 (const I &x, const I &y)$/;" f +f1 testsuite/libgomp.c++/taskloop-7.C /^f1 (const std::vector::const_iterator &x,$/;" f +f1 testsuite/libgomp.c++/taskloop-8.C /^f1 (const std::basic_string::iterator &x,$/;" f +f1 testsuite/libgomp.c++/taskloop-9.C /^f1 (const I &x, const I &y)$/;" f +f1 testsuite/libgomp.c/appendix-a/a.19.1.c /^f1 (int *q)$/;" f +f1 testsuite/libgomp.c/atomic-1.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/atomic-10.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/atomic-18.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/debug-1.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/depend-5.c /^f1 (int ifval)$/;" f +f1 testsuite/libgomp.c/for-2.h /^N(f1) (void)$/;" f +f1 testsuite/libgomp.c/linear-1.c /^f1 (int i)$/;" f +f1 testsuite/libgomp.c/loop-13.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/loop-14.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/loop-15.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/pr35130.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/pr66199-1.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-2.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-3.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-4.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-5.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-7.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr66199-8.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/pr70680-1.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/pr70680-2.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/private-1.c /^f1 (int i, int j, int k)$/;" f +f1 testsuite/libgomp.c/task-1.c /^f1 (int i, int j, int k)$/;" f +f1 testsuite/libgomp.c/task-2.c /^f1 (void)$/;" f +f1 testsuite/libgomp.c/taskloop-2.c /^f1 (long a, long b)$/;" f +f1 testsuite/libgomp.c/taskloop-3.c /^f1 (int x)$/;" f +f1 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1,/;" v +f1 testsuite/libgomp.fortran/retval1.f90 /^function f1 /;" f +f1 testsuite/libgomp.fortran/retval2.f90 /^ real :: f1$/;" v +f1 testsuite/libgomp.fortran/retval2.f90 /^function f1 /;" f +f1 testsuite/libgomp.fortran/taskloop2.f90 /^ subroutine f1 /;" s +f1 testsuite/libgomp.fortran/taskloop3.f90 /^ function f1 /;" f +f1 testsuite/libgomp.fortran/udr15.f90 /^ integer function f1 /;" f module:udr15m1 +f1 testsuite/libgomp.fortran/udr8.f90 /^ integer function f1 /;" f module:udr8m1 +f1 testsuite/libgomp.fortran/udr9.f90 /^ integer function f1 /;" f module:udr9m1 +f1 testsuite/libgomp.fortran/vla7.f90 /^ function f1 /;" f +f1 testsuite/libgomp.fortran/workshare2.f90 /^subroutine f1$/;" s +f10 testsuite/libgomp.c++/collapse-2.C /^f10 (J x, J y, J z)$/;" f +f10 testsuite/libgomp.c++/for-1.C /^f10 (const I &x, const I &y)$/;" f +f10 testsuite/libgomp.c++/for-2.C /^f10 (T x, T y)$/;" f +f10 testsuite/libgomp.c++/for-3.C /^f10 (const typename std::vector::const_iterator &x,$/;" f +f10 testsuite/libgomp.c++/for-4.C /^f10 (const typename std::basic_string::iterator &x,$/;" f +f10 testsuite/libgomp.c++/for-5.C /^f10 (const I &x, const I &y)$/;" f +f10 testsuite/libgomp.c++/for-8.C /^f10 (const I &x, const I &y)$/;" f +f10 testsuite/libgomp.c++/linear-1.C /^f10 (T &i, long &step)$/;" f +f10 testsuite/libgomp.c++/taskloop-6.C /^f10 (const I &x, const I &y)$/;" f +f10 testsuite/libgomp.c++/taskloop-7.C /^f10 (const typename std::vector::const_iterator &x,$/;" f +f10 testsuite/libgomp.c++/taskloop-8.C /^f10 (const typename std::basic_string::iterator &x,$/;" f +f10 testsuite/libgomp.c++/taskloop-9.C /^f10 (const I &x, const I &y)$/;" f +f10 testsuite/libgomp.c/for-2.h /^N(f10) (void)$/;" f +f10 testsuite/libgomp.c/linear-1.c /^f10 (int i, long step)$/;" f +f11 testsuite/libgomp.c++/for-1.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/for-2.C /^f11 (T x, long y)$/;" f +f11 testsuite/libgomp.c++/for-3.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/for-4.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/for-5.C /^f11 (T i, const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/for-8.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/linear-1.C /^f11 (short int i, char k, char step)$/;" f +f11 testsuite/libgomp.c++/taskloop-6.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/taskloop-7.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/taskloop-8.C /^f11 (const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c++/taskloop-9.C /^f11 (T i, const T &x, const T &y)$/;" f +f11 testsuite/libgomp.c/for-2.h /^N(f11) (int n)$/;" f +f11 testsuite/libgomp.c/linear-1.c /^f11 (short int i, char k, char step)$/;" f +f12 testsuite/libgomp.c++/for-1.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/for-2.C /^f12 (T x, T y)$/;" f +f12 testsuite/libgomp.c++/for-3.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/for-4.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/for-5.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/for-8.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/linear-1.C /^f12 (long long int i, long long int k, int step)$/;" f +f12 testsuite/libgomp.c++/taskloop-6.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/taskloop-7.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/taskloop-8.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c++/taskloop-9.C /^f12 (const T &x, const T &y)$/;" f +f12 testsuite/libgomp.c/for-2.h /^N(f12) (int n)$/;" f +f12 testsuite/libgomp.c/linear-1.c /^f12 (long long int i, long long int k, int step)$/;" f +f13 testsuite/libgomp.c++/for-1.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/for-3.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/for-4.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/for-8.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/linear-1.C /^f13 (int &i, long long int step)$/;" f +f13 testsuite/libgomp.c++/taskloop-6.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/taskloop-7.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c++/taskloop-8.C /^ f13 (const T &x, const T &y)$/;" f struct:K +f13 testsuite/libgomp.c/for-2.h /^N(f13) (void)$/;" f +f13 testsuite/libgomp.c/linear-1.c /^f13 (int i, long long int step)$/;" f +f14 testsuite/libgomp.c++/linear-1.C /^f14 (short int &i, char &k, int &step)$/;" f +f14 testsuite/libgomp.c++/taskloop-6.C /^f14 (const I &x, const I &y)$/;" f +f14 testsuite/libgomp.c++/taskloop-7.C /^f14 (const std::vector::const_iterator &x,$/;" f +f14 testsuite/libgomp.c/for-2.h /^N(f14) (void)$/;" f +f14 testsuite/libgomp.c/linear-1.c /^f14 (short int i, char k, int step)$/;" f +f15 testsuite/libgomp.c++/linear-1.C /^f15 (long long int i, long long int k, long int step)$/;" f +f15 testsuite/libgomp.c++/taskloop-6.C /^f15 (const I &x, const I &y)$/;" f +f15 testsuite/libgomp.c++/taskloop-7.C /^f15 (const std::vector::const_iterator &x,$/;" f +f15 testsuite/libgomp.c/linear-1.c /^f15 (long long int i, long long int k, long int step)$/;" f +f16 testsuite/libgomp.c++/linear-1.C /^f16 (int i, long long int step)$/;" f +f16 testsuite/libgomp.c++/taskloop-6.C /^f16 (I i, const I &x, const I &y)$/;" f +f16 testsuite/libgomp.c++/taskloop-7.C /^f16 (std::vector::const_iterator i,$/;" f +f16 testsuite/libgomp.c/linear-1.c /^f16 (int i, long long int step)$/;" f +f17 testsuite/libgomp.c++/linear-1.C /^f17 (short int i, char k, int step)$/;" f +f17 testsuite/libgomp.c++/taskloop-6.C /^f17 (J j)$/;" f +f17 testsuite/libgomp.c++/taskloop-7.C /^f17 (J j)$/;" f +f17 testsuite/libgomp.c/linear-1.c /^f17 (short int i, char k, int step)$/;" f +f18 testsuite/libgomp.c++/linear-1.C /^f18 (T i, T k, long int step)$/;" f +f18 testsuite/libgomp.c++/taskloop-6.C /^f18 (const I &x, const I &y)$/;" f +f18 testsuite/libgomp.c++/taskloop-7.C /^f18 (const typename std::vector::const_iterator &x,$/;" f +f18 testsuite/libgomp.c/linear-1.c /^f18 (long long int i, long long int k, long int step)$/;" f +f19 testsuite/libgomp.c++/taskloop-6.C /^f19 (const T &x, const T &y)$/;" f +f19 testsuite/libgomp.c++/taskloop-7.C /^f19 (const T &x, const T &y)$/;" f +f2 testsuite/libgomp.c++/collapse-2.C /^f2 (J x, J y, J z)$/;" f +f2 testsuite/libgomp.c++/ctor-13.C /^void f2(B &a)$/;" f +f2 testsuite/libgomp.c++/doacross-1.C /^f2 (int a, int b, int c, int d, int e, int f, int g, int h, int &r1, int &r2, int &r3)$/;" f +f2 testsuite/libgomp.c++/for-1.C /^f2 (const I &x, const I &y)$/;" f +f2 testsuite/libgomp.c++/for-2.C /^f2 (int x, int y)$/;" f +f2 testsuite/libgomp.c++/for-3.C /^f2 (const std::vector::const_iterator &x,$/;" f +f2 testsuite/libgomp.c++/for-4.C /^f2 (const std::basic_string::iterator &x,$/;" f +f2 testsuite/libgomp.c++/for-5.C /^f2 (const I &x, const I &y)$/;" f +f2 testsuite/libgomp.c++/for-6.C /^f2 ()$/;" f +f2 testsuite/libgomp.c++/for-7.C /^f2 ()$/;" f +f2 testsuite/libgomp.c++/for-8.C /^f2 (const I &x, const I &y)$/;" f +f2 testsuite/libgomp.c++/linear-1.C /^f2 (short int &i, char k)$/;" f +f2 testsuite/libgomp.c++/loop-5.C /^int f2() { check |= 2; return 11; }$/;" f +f2 testsuite/libgomp.c++/pr43893.C /^f2 ()$/;" f +f2 testsuite/libgomp.c++/pr69555-1.C /^f2 (int y)$/;" f +f2 testsuite/libgomp.c++/pr69555-2.C /^f2 (int y)$/;" f +f2 testsuite/libgomp.c++/task-1.C /^f2 (void)$/;" f +f2 testsuite/libgomp.c++/task-6.C /^f2 (void)$/;" f +f2 testsuite/libgomp.c++/taskloop-6.C /^f2 (const I &x, const I &y)$/;" f +f2 testsuite/libgomp.c++/taskloop-7.C /^f2 (const std::vector::const_iterator &x,$/;" f +f2 testsuite/libgomp.c++/taskloop-8.C /^f2 (const std::basic_string::iterator &x,$/;" f +f2 testsuite/libgomp.c++/taskloop-9.C /^f2 (const I &x, const I &y)$/;" f +f2 testsuite/libgomp.c/appendix-a/a.19.1.c /^f2 (int *q)$/;" f +f2 testsuite/libgomp.c/atomic-1.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/atomic-10.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/atomic-18.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/debug-1.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/for-2.h /^N(f2) (void)$/;" f +f2 testsuite/libgomp.c/linear-1.c /^f2 (short int i, char k)$/;" f +f2 testsuite/libgomp.c/loop-13.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/loop-14.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/loop-15.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/pr35130.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/pr66199-1.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-2.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-3.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-4.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-5.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-6.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-7.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-8.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr66199-9.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/pr70680-1.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/pr70680-2.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/private-1.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/task-1.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/task-2.c /^f2 (void)$/;" f +f2 testsuite/libgomp.c/taskloop-2.c /^f2 (long a, long b, long c)$/;" f +f2 testsuite/libgomp.c/taskloop-3.c /^f2 (void)$/;" f +f2 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2,/;" v +f2 testsuite/libgomp.fortran/retval1.f90 /^function f2 /;" f +f2 testsuite/libgomp.fortran/taskloop2.f90 /^ subroutine f2 /;" s +f2 testsuite/libgomp.fortran/taskloop3.f90 /^ subroutine f2 /;" s +f2 testsuite/libgomp.fortran/udr15.f90 /^ type(dt) function f2 /;" f module:udr15m2 +f2 testsuite/libgomp.fortran/udr8.f90 /^ type(dt) function f2 /;" f module:udr8m2 +f2 testsuite/libgomp.fortran/udr9.f90 /^ type(dt) function f2 /;" f module:udr9m2 +f2 testsuite/libgomp.fortran/vla7.f90 /^ character (6) :: c, f2$/;" v +f2 testsuite/libgomp.fortran/vla7.f90 /^function f2 /;" f +f2 testsuite/libgomp.fortran/workshare2.f90 /^subroutine f2$/;" s +f20 testsuite/libgomp.c++/taskloop-6.C /^f20 (const T &x, const T &y)$/;" f +f20 testsuite/libgomp.c++/taskloop-7.C /^f20 (const T &x, const T &y)$/;" f +f2_tpf_static32 testsuite/libgomp.c/pr81875.c /^f2_tpf_static32 (void)$/;" f +f3 testsuite/libgomp.c++/collapse-2.C /^f3 (J x, J y, J z)$/;" f +f3 testsuite/libgomp.c++/ctor-13.C /^void f3(B &a)$/;" f +f3 testsuite/libgomp.c++/doacross-1.C /^f3 (const I &a, const I &b, const I &c, const I &d,$/;" f +f3 testsuite/libgomp.c++/for-1.C /^f3 (const I &x, const I &y)$/;" f +f3 testsuite/libgomp.c++/for-2.C /^f3 (int x, int y)$/;" f +f3 testsuite/libgomp.c++/for-3.C /^f3 (const std::vector::const_iterator &x,$/;" f +f3 testsuite/libgomp.c++/for-4.C /^f3 (const std::basic_string::iterator &x,$/;" f +f3 testsuite/libgomp.c++/for-5.C /^f3 (const I &x, const I &y)$/;" f +f3 testsuite/libgomp.c++/for-6.C /^f3 ()$/;" f +f3 testsuite/libgomp.c++/for-7.C /^f3 ()$/;" f +f3 testsuite/libgomp.c++/for-8.C /^f3 (const I &x, const I &y)$/;" f +f3 testsuite/libgomp.c++/linear-1.C /^f3 (T i, T k)$/;" f +f3 testsuite/libgomp.c++/loop-5.C /^int f3() { check |= 4; return 2; }$/;" f +f3 testsuite/libgomp.c++/pr43893.C /^f3 ()$/;" f +f3 testsuite/libgomp.c++/pr69555-1.C /^f3 (int y)$/;" f +f3 testsuite/libgomp.c++/task-1.C /^f3 (int i, int j, int k)$/;" f +f3 testsuite/libgomp.c++/task-6.C /^f3 (T i, T j, T k)$/;" f +f3 testsuite/libgomp.c++/taskloop-6.C /^f3 (const I &x, const I &y)$/;" f +f3 testsuite/libgomp.c++/taskloop-7.C /^f3 (const std::vector::const_iterator &x,$/;" f +f3 testsuite/libgomp.c++/taskloop-8.C /^f3 (const std::basic_string::iterator &x,$/;" f +f3 testsuite/libgomp.c++/taskloop-9.C /^f3 (const I &x, const I &y)$/;" f +f3 testsuite/libgomp.c/atomic-10.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/atomic-18.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/debug-1.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/for-2.h /^N(f3) (long long n1, long long n2, long long s3)$/;" f +f3 testsuite/libgomp.c/linear-1.c /^f3 (long long int i, long long int k)$/;" f +f3 testsuite/libgomp.c/loop-13.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/loop-14.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/loop-15.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/pr35130.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/pr66199-1.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-2.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-3.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-4.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-5.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-6.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-7.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-8.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr66199-9.c /^f3 (long a1, long b1, long a2, long b2)$/;" f +f3 testsuite/libgomp.c/pr70680-1.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/pr70680-2.c /^f3 (void)$/;" f +f3 testsuite/libgomp.c/task-1.c /^f3 (int i, int j, int k)$/;" f +f3 testsuite/libgomp.c/taskloop-2.c /^f3 (long a, long b)$/;" f +f3 testsuite/libgomp.c/taskloop-3.c /^f3 (long long a, long long b, long long c)$/;" f +f3 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2, f3,/;" v +f3 testsuite/libgomp.fortran/retval1.f90 /^function f3 /;" f +f3 testsuite/libgomp.fortran/taskloop2.f90 /^ subroutine f3 /;" s +f3 testsuite/libgomp.fortran/taskloop3.f90 /^ function f3 /;" f +f3 testsuite/libgomp.fortran/udr15.f90 /^ integer function f3 /;" f module:udr15m1 +f3 testsuite/libgomp.fortran/vla7.f90 /^ function f3 /;" f +f4 testsuite/libgomp.c++/collapse-2.C /^f4 (J x, J y, J z)$/;" f +f4 testsuite/libgomp.c++/ctor-13.C /^void f4()$/;" f +f4 testsuite/libgomp.c++/doacross-1.C /^f4 (int a, int b, int c, int d, int e, int f, int g, int h, int &r1, int &r2, int &r3)$/;" f +f4 testsuite/libgomp.c++/for-1.C /^f4 (const I &x, const I &y)$/;" f +f4 testsuite/libgomp.c++/for-2.C /^f4 (int x, int y)$/;" f +f4 testsuite/libgomp.c++/for-3.C /^f4 (const std::vector::const_iterator &x,$/;" f +f4 testsuite/libgomp.c++/for-4.C /^f4 (const std::basic_string::iterator &x,$/;" f +f4 testsuite/libgomp.c++/for-5.C /^f4 (const I &x, const I &y)$/;" f +f4 testsuite/libgomp.c++/for-6.C /^f4 ()$/;" f +f4 testsuite/libgomp.c++/for-7.C /^f4 ()$/;" f +f4 testsuite/libgomp.c++/for-8.C /^f4 (const I &x, const I &y)$/;" f +f4 testsuite/libgomp.c++/linear-1.C /^f4 (T &i)$/;" f +f4 testsuite/libgomp.c++/pr43893.C /^f4 ()$/;" f +f4 testsuite/libgomp.c++/pr69555-1.C /^f4 (int y)$/;" f +f4 testsuite/libgomp.c++/taskloop-6.C /^f4 (const I &x, const I &y)$/;" f +f4 testsuite/libgomp.c++/taskloop-7.C /^f4 (const std::vector::const_iterator &x,$/;" f +f4 testsuite/libgomp.c++/taskloop-8.C /^f4 (const std::basic_string::iterator &x,$/;" f +f4 testsuite/libgomp.c++/taskloop-9.C /^f4 (const I &x, const I &y)$/;" f +f4 testsuite/libgomp.c/atomic-10.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/atomic-18.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/debug-1.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/for-2.h /^N(f4) (void)$/;" f +f4 testsuite/libgomp.c/linear-1.c /^f4 (int i)$/;" f +f4 testsuite/libgomp.c/pr35130.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/pr66199-1.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr66199-2.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr66199-4.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr66199-5.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr66199-7.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr66199-8.c /^f4 (long a1, long b1, long a2, long b2)$/;" f +f4 testsuite/libgomp.c/pr70680-1.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/pr70680-2.c /^f4 (void)$/;" f +f4 testsuite/libgomp.c/taskloop-2.c /^f4 (long a, long b, long c, long d)$/;" f +f4 testsuite/libgomp.c/taskloop-3.c /^f4 (long long a, long long b, long long c, long long d,$/;" f +f4 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2, f3, e3, f4,/;" v +f4 testsuite/libgomp.fortran/retval1.f90 /^function f4 /;" f +f4 testsuite/libgomp.fortran/taskloop2.f90 /^ subroutine f4 /;" s +f4 testsuite/libgomp.fortran/taskloop3.f90 /^ function f4 /;" f +f4 testsuite/libgomp.fortran/vla7.f90 /^ function f4 /;" f +f5 testsuite/libgomp.c++/collapse-2.C /^f5 (J x, J y, J z)$/;" f +f5 testsuite/libgomp.c++/for-1.C /^f5 (const I &x, const I &y)$/;" f +f5 testsuite/libgomp.c++/for-2.C /^f5 (int x, int y)$/;" f +f5 testsuite/libgomp.c++/for-3.C /^f5 (const std::vector::const_iterator &x,$/;" f +f5 testsuite/libgomp.c++/for-4.C /^f5 (const std::basic_string::iterator &x,$/;" f +f5 testsuite/libgomp.c++/for-5.C /^f5 (const I &x, const I &y)$/;" f +f5 testsuite/libgomp.c++/for-6.C /^f5 ()$/;" f +f5 testsuite/libgomp.c++/for-7.C /^f5 ()$/;" f +f5 testsuite/libgomp.c++/for-8.C /^f5 (const I &x, const I &y)$/;" f +f5 testsuite/libgomp.c++/linear-1.C /^f5 (short int i, char &k)$/;" f +f5 testsuite/libgomp.c++/taskloop-6.C /^f5 (const I &x, const I &y)$/;" f +f5 testsuite/libgomp.c++/taskloop-7.C /^f5 (const std::vector::const_iterator &x,$/;" f +f5 testsuite/libgomp.c++/taskloop-8.C /^f5 (const std::basic_string::iterator &x,$/;" f +f5 testsuite/libgomp.c++/taskloop-9.C /^f5 (const I &x, const I &y)$/;" f +f5 testsuite/libgomp.c/debug-1.c /^f5 (void)$/;" f +f5 testsuite/libgomp.c/for-2.h /^N(f5) (int n11, int n12, int n21, int n22, int n31, int n32,$/;" f +f5 testsuite/libgomp.c/linear-1.c /^f5 (short int i, char k)$/;" f +f5 testsuite/libgomp.c/taskloop-2.c /^f5 (long a, long b, long c, long d)$/;" f +f5 testsuite/libgomp.fortran/retval1.f90 /^ real :: f1, f2, e2, f3, e3, f4, e4, f5$/;" v +f5 testsuite/libgomp.fortran/retval1.f90 /^function f5 /;" f +f5 testsuite/libgomp.fortran/taskloop2.f90 /^ subroutine f5 /;" s +f6 testsuite/libgomp.c++/collapse-2.C /^f6 (J x, J y, J z)$/;" f +f6 testsuite/libgomp.c++/for-1.C /^f6 (const I &x, const I &y)$/;" f +f6 testsuite/libgomp.c++/for-2.C /^f6 (int x, int y)$/;" f +f6 testsuite/libgomp.c++/for-3.C /^f6 (const std::vector::const_iterator &x,$/;" f +f6 testsuite/libgomp.c++/for-4.C /^f6 (const std::basic_string::iterator &x,$/;" f +f6 testsuite/libgomp.c++/for-5.C /^f6 (const I &x, const I &y)$/;" f +f6 testsuite/libgomp.c++/for-6.C /^f6 ()$/;" f +f6 testsuite/libgomp.c++/for-7.C /^f6 ()$/;" f +f6 testsuite/libgomp.c++/for-8.C /^f6 (const I &x, const I &y)$/;" f +f6 testsuite/libgomp.c++/linear-1.C /^f6 (long long int i, long long int k)$/;" f +f6 testsuite/libgomp.c++/taskloop-6.C /^f6 (const I &x, const I &y)$/;" f +f6 testsuite/libgomp.c++/taskloop-7.C /^f6 (const std::vector::const_iterator &x,$/;" f +f6 testsuite/libgomp.c++/taskloop-8.C /^f6 (const std::basic_string::iterator &x,$/;" f +f6 testsuite/libgomp.c++/taskloop-9.C /^f6 (const I &x, const I &y)$/;" f +f6 testsuite/libgomp.c/debug-1.c /^f6 (void)$/;" f +f6 testsuite/libgomp.c/for-2.h /^N(f6) (int n11, int n12, int n21, int n22, long long n31, long long n32,$/;" f +f6 testsuite/libgomp.c/linear-1.c /^f6 (long long int i, long long int k)$/;" f +f6 testsuite/libgomp.fortran/udr15.f90 /^ type(dt) function f6 /;" f module:udr15m2 +f7 testsuite/libgomp.c++/collapse-2.C /^f7 (J x, J y, J z)$/;" f +f7 testsuite/libgomp.c++/for-1.C /^f7 (I i, const I &x, const I &y)$/;" f +f7 testsuite/libgomp.c++/for-2.C /^f7 (int i, int x, int y)$/;" f +f7 testsuite/libgomp.c++/for-3.C /^f7 (std::vector::const_iterator i,$/;" f +f7 testsuite/libgomp.c++/for-4.C /^f7 (std::basic_string::iterator i,$/;" f +f7 testsuite/libgomp.c++/for-5.C /^f7 (I i, const I &x, const I &y)$/;" f +f7 testsuite/libgomp.c++/for-8.C /^f7 (I i, const I &x, const I &y)$/;" f +f7 testsuite/libgomp.c++/linear-1.C /^f7 (int &i)$/;" f +f7 testsuite/libgomp.c++/taskloop-6.C /^f7 (I i, const I &x, const I &y)$/;" f +f7 testsuite/libgomp.c++/taskloop-7.C /^f7 (std::vector::const_iterator i,$/;" f +f7 testsuite/libgomp.c++/taskloop-8.C /^f7 (std::basic_string::iterator i,$/;" f +f7 testsuite/libgomp.c++/taskloop-9.C /^f7 (I i, const I &x, const I &y)$/;" f +f7 testsuite/libgomp.c/debug-1.c /^f7 (void)$/;" f +f7 testsuite/libgomp.c/for-2.h /^N(f7) (void)$/;" f +f7 testsuite/libgomp.c/linear-1.c /^f7 (int i)$/;" f +f8 testsuite/libgomp.c++/collapse-2.C /^f8 (J x, J y, J z)$/;" f +f8 testsuite/libgomp.c++/ctor-13.C /^void f8()$/;" f +f8 testsuite/libgomp.c++/for-1.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/for-2.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/for-3.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/for-4.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/for-5.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/for-8.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/linear-1.C /^f8 (short int i, char k)$/;" f +f8 testsuite/libgomp.c++/taskloop-6.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/taskloop-7.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/taskloop-8.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c++/taskloop-9.C /^f8 (J j)$/;" f +f8 testsuite/libgomp.c/for-2.h /^N(f8) (void)$/;" f +f8 testsuite/libgomp.c/linear-1.c /^f8 (short int i, char k)$/;" f +f9 testsuite/libgomp.c++/collapse-2.C /^f9 (J x, J y, J z)$/;" f +f9 testsuite/libgomp.c++/for-1.C /^f9 (const I &x, const I &y)$/;" f +f9 testsuite/libgomp.c++/for-2.C /^f9 (T x, T y)$/;" f +f9 testsuite/libgomp.c++/for-3.C /^f9 (const typename std::vector::const_iterator &x,$/;" f +f9 testsuite/libgomp.c++/for-4.C /^f9 (const typename std::basic_string::iterator &x,$/;" f +f9 testsuite/libgomp.c++/for-5.C /^f9 (J j)$/;" f +f9 testsuite/libgomp.c++/for-8.C /^f9 (const I &x, const I &y)$/;" f +f9 testsuite/libgomp.c++/linear-1.C /^f9 (long long int i, long long int k)$/;" f +f9 testsuite/libgomp.c++/taskloop-6.C /^f9 (const I &x, const I &y)$/;" f +f9 testsuite/libgomp.c++/taskloop-7.C /^f9 (const typename std::vector::const_iterator &x,$/;" f +f9 testsuite/libgomp.c++/taskloop-8.C /^f9 (const typename std::basic_string::iterator &x,$/;" f +f9 testsuite/libgomp.c++/taskloop-9.C /^f9 (J j)$/;" f +f9 testsuite/libgomp.c/for-2.h /^N(f9) (void)$/;" f +f9 testsuite/libgomp.c/linear-1.c /^f9 (long long int i, long long int k)$/;" f +f_1 testsuite/libgomp.c/sections-1.c /^static void f_1 (void *dummy)$/;" f file: +f_2 testsuite/libgomp.c/sections-1.c /^static void f_2 (void *dummy)$/;" f file: +f_copy testsuite/libgomp.c/single-1.c /^static void f_copy (void *dummy)$/;" f file: +f_nocopy testsuite/libgomp.c/single-1.c /^static void f_nocopy (void *dummy)$/;" f file: +f_static_1 testsuite/libgomp.c/loop-2.c /^static void f_static_1 (void *dummy)$/;" f file: +fact testsuite/libgomp.oacc-fortran/routine-1.f90 /^recursive function fact /;" f +fact testsuite/libgomp.oacc-fortran/routine-2.f90 /^ recursive function fact /;" f module:m1 +fact testsuite/libgomp.oacc-fortran/routine-3.f90 /^ integer, external :: fact$/;" v +fact testsuite/libgomp.oacc-fortran/routine-3.f90 /^recursive function fact /;" f +fact testsuite/libgomp.oacc-fortran/routine-9.f90 /^ integer, external :: fact$/;" v program:main +fact testsuite/libgomp.oacc-fortran/routine-9.f90 /^recursive function fact /;" f +failures testsuite/libgomp.c/sort-1.c /^int failures;$/;" v +fdat testsuite/libgomp.fortran/jacobi.f 34;" c program:main +fdat testsuite/libgomp.fortran/jacobi.f 85;" c subroutine:driver +fexp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ real fgot, fexp,/;" v program:main +fexp testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ real fgot, fexp$/;" v program:main +fgot testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ real fgot,/;" v program:main +fgot testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ real fgot,/;" v program:main +fib testsuite/libgomp.c/examples-4/declare_target-1.c /^int fib (int n)$/;" f +fib testsuite/libgomp.c/examples-4/simd-7.c /^int fib( int n )$/;" f +fib testsuite/libgomp.fortran/examples-4/declare_target-1.f90 /^ integer recursive function fib /;" f module:e_53_1_mod +fib testsuite/libgomp.fortran/examples-4/declare_target-2.f90 /^ integer :: x, fib$/;" v program:e_53_2 +fib testsuite/libgomp.fortran/examples-4/declare_target-2.f90 /^integer recursive function fib /;" f +fib testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ integer, external :: fib$/;" v program:fibonacci +fib testsuite/libgomp.fortran/examples-4/simd-7.f90 /^recursive function fib(/;" f +fib_ref testsuite/libgomp.c/examples-4/simd-7.c /^void fib_ref()$/;" f +fib_ref testsuite/libgomp.fortran/examples-4/simd-7.f90 /^subroutine fib_ref(/;" s +fib_wrapper testsuite/libgomp.c/examples-4/declare_target-1.c /^int fib_wrapper (int n)$/;" f +fib_wrapper testsuite/libgomp.fortran/examples-4/declare_target-1.f90 /^ integer function fib_wrapper /;" f module:e_53_1_mod +fibonacci testsuite/libgomp.fortran/examples-4/simd-7.f90 /^program fibonacci$/;" p +file_name plugin/plugin-hsa.c /^ char *file_name;$/;" m struct:brig_library_info file: +filter_mode plugin/hsa_ext_finalize.h /^ hsa_ext_sampler_filter_mode_t filter_mode;$/;" m struct:hsa_ext_sampler_descriptor_s +final_task libgomp.h /^ bool final_task;$/;" m struct:gomp_task +final_task libgomp.h /^ bool final_task;$/;" m struct:gomp_tdg_task +find_empty_slot_for_expand hashtab.h /^find_empty_slot_for_expand (htab_t htab, hashval_t hash)$/;" f +find_pset oacc-parallel.c /^find_pset (int pos, size_t mapnum, unsigned short *kinds)$/;" f file: +fini_device_func libgomp.h /^ __typeof (GOMP_OFFLOAD_fini_device) *fini_device_func;$/;" m struct:gomp_device_descr +fini_streams_for_device plugin/plugin-nvptx.c /^fini_streams_for_device (struct ptx_device *ptx_dev)$/;" f file: +fini_timers testsuite/libgomp.oacc-c-c++-common/timer.h /^fini_timers (void)$/;" f +first_module plugin/plugin-hsa.c /^ struct module_info *first_module;$/;" m struct:agent_info typeref:struct:agent_info::module_info file: +firstpriv testsuite/libgomp.c/depend-1.c /^firstpriv (void)$/;" f +firstpriv testsuite/libgomp.fortran/depend-1.f90 /^ subroutine firstpriv$/;" s +firstprivate testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^program firstprivate$/;" p +flags libgomp.h /^ unsigned int flags;$/;" m struct:gomp_target_task +flattened libgomp.h /^ bool flattened;$/;" m struct:gomp_doacross_work_share +float2 testsuite/libgomp.hsa.c/pr69568.c /^typedef float float2 __attribute__ ((vector_size (8)));$/;" t file: +fn libgomp.h /^ void (*fn) (void *);$/;" m struct:gomp_target_task +fn libgomp.h /^ void (*fn) (void *);$/;" m struct:gomp_task +fn libgomp.h /^ void (*fn) (void *);$/;" m struct:gomp_tdg_task +fn libgomp.h /^ void (*fn) (void *data);$/;" m struct:gomp_thread +fn plugin/plugin-nvptx.c /^ CUfunction fn;$/;" m struct:targ_fn_descriptor file: +fn plugin/plugin-nvptx.c /^ const char *fn;$/;" m struct:targ_fn_launch file: +fn tdg.h /^ void (*fn) (void *);$/;" m struct:gomp_data_store +fn team.c /^ void (*fn) (void *);$/;" m struct:gomp_thread_start_data file: +fn testsuite/libgomp.fortran/udr4.f90 /^elemental function fn /;" f +fn0 testsuite/libgomp.fortran/threadprivate4.f90 /^ subroutine fn0$/;" s module:threadprivate4 +fn1 testsuite/libgomp.c++/target-2.C /^fn1 (double *x, double *y, int z)$/;" f +fn1 testsuite/libgomp.c/appendix-a/a.18.1.c /^fn1 (int i)$/;" f +fn1 testsuite/libgomp.c/target-1.c /^fn1 (double *x, double *y, int z)$/;" f +fn1 testsuite/libgomp.c/target-2.c /^fn1 (double *x, double *y, int z)$/;" f +fn1 testsuite/libgomp.fortran/threadprivate4.f90 /^ subroutine fn1$/;" s module:threadprivate4 +fn1 testsuite/libgomp.fortran/udr12.f90 /^elemental function fn1 /;" f +fn1 testsuite/libgomp.fortran/udr13.f90 /^function fn1 /;" f +fn2 testsuite/libgomp.c++/target-2.C /^fn2 (int x, double (&dr) [1024], double *&er)$/;" f +fn2 testsuite/libgomp.c/appendix-a/a.18.1.c /^fn2 (int a, int b)$/;" f +fn2 testsuite/libgomp.c/target-1.c /^fn2 (int x, int y, int z)$/;" f +fn2 testsuite/libgomp.c/target-2.c /^fn2 (int x)$/;" f +fn2 testsuite/libgomp.fortran/threadprivate4.f90 /^ subroutine fn2$/;" s module:threadprivate4 +fn2 testsuite/libgomp.fortran/udr12.f90 /^elemental function fn2 /;" f +fn2 testsuite/libgomp.fortran/udr13.f90 /^function fn2 /;" f +fn3 testsuite/libgomp.c/pr66714.c /^fn3 (int x)$/;" f +fn3 testsuite/libgomp.c/target-1.c /^fn3 (int x)$/;" f +fn3 testsuite/libgomp.c/target-2.c /^fn3 (int x)$/;" f +fn3 testsuite/libgomp.fortran/threadprivate4.f90 /^ subroutine fn3$/;" s module:threadprivate4 +fn3 testsuite/libgomp.fortran/udr13.f90 /^function fn3 /;" f +fn4 testsuite/libgomp.c/target-1.c /^fn4 (int x, double *p)$/;" f +fn4 testsuite/libgomp.c/target-2.c /^fn4 (int x)$/;" f +fn_data libgomp.h /^ void *fn_data;$/;" m struct:gomp_task +fn_data libgomp.h /^ void *fn_data;$/;" m struct:gomp_tdg_task +fn_data tdg.h /^ void *fn_data;$/;" m struct:gomp_data_store +fn_data team.c /^ void *fn_data;$/;" m struct:gomp_thread_start_data file: +fn_descs plugin/plugin-nvptx.c /^ const struct targ_fn_launch *fn_descs;$/;" m struct:nvptx_tdata typeref:struct:nvptx_tdata::targ_fn_launch file: +fn_num plugin/plugin-nvptx.c /^ unsigned fn_num;$/;" m struct:nvptx_tdata file: +fns plugin/plugin-nvptx.c /^ struct targ_fn_descriptor *fns; \/* Array of functions. *\/$/;" m struct:ptx_image_data typeref:struct:ptx_image_data::targ_fn_descriptor file: +foo testsuite/libgomp.c++/atomic-1.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-11.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-12.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-13.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-15.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-3.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-4.C /^foo (void)$/;" f +foo testsuite/libgomp.c++/atomic-5.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-6.C /^foo (void)$/;" f +foo testsuite/libgomp.c++/atomic-7.C /^foo (void)$/;" f +foo testsuite/libgomp.c++/atomic-8.C /^foo ()$/;" f +foo testsuite/libgomp.c++/atomic-9.C /^foo ()$/;" f +foo testsuite/libgomp.c++/cancel-for-2.C /^foo (int *x)$/;" f +foo testsuite/libgomp.c++/cancel-parallel-2.C /^foo (int *x)$/;" f file: +foo testsuite/libgomp.c++/cancel-parallel-3.C /^foo ()$/;" f +foo testsuite/libgomp.c++/cancel-taskgroup-3.C /^foo ()$/;" f +foo testsuite/libgomp.c++/ctor-1.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-10.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-2.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-3.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-4.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-5.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-6.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-7.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-8.C /^void foo()$/;" f +foo testsuite/libgomp.c++/ctor-9.C /^void foo()$/;" f +foo testsuite/libgomp.c++/declare_target-1.C /^ int foo () { return a^0x01; }$/;" f class:typeY +foo testsuite/libgomp.c++/examples-4/declare_target-2.C /^ int foo () { return a^0x01; }$/;" f class:typeY +foo testsuite/libgomp.c++/loop-3.C /^foo ()$/;" f +foo testsuite/libgomp.c++/loop-7.C /^foo (T r)$/;" f +foo testsuite/libgomp.c++/master-1.C /^foo ()$/;" f +foo testsuite/libgomp.c++/nested-1.C /^int foo()$/;" f +foo testsuite/libgomp.c++/parallel-1.C /^foo (void)$/;" f +foo testsuite/libgomp.c++/pr26943.C /^foo ()$/;" f +foo testsuite/libgomp.c++/pr27337.C /^foo ()$/;" f +foo testsuite/libgomp.c++/pr30703.C /^foo (A a, A b)$/;" f +foo testsuite/libgomp.c++/pr48869.C /^ void foo () {}$/;" f struct:A +foo testsuite/libgomp.c++/pr48869.C /^ void foo () {}$/;" f struct:B +foo testsuite/libgomp.c++/pr48869.C /^foo (B<6> b6)$/;" f +foo testsuite/libgomp.c++/pr58706.C /^foo ()$/;" f +foo testsuite/libgomp.c++/pr63248.C /^foo (T A, T B)$/;" f +foo testsuite/libgomp.c++/pr66702-1.C /^foo (int a, int b, int *c, int d)$/;" f +foo testsuite/libgomp.c++/pr66702-2.C /^foo (int a, S b, T c)$/;" f +foo testsuite/libgomp.c++/pr70376.C /^ void foo() { }$/;" f struct:A +foo testsuite/libgomp.c++/pr81314.C /^foo (S<2> &x)$/;" f +foo testsuite/libgomp.c++/reduction-10.C /^S::foo (int p1, long p2, long p3, int p4, int p5, long p6, short p7)$/;" f class:S +foo testsuite/libgomp.c++/reduction-10.C /^foo (A (*&x)[3][N], M *y, B (&w)[1][N], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c++/reduction-11.C /^S::foo (int s, int t)$/;" f class:S +foo testsuite/libgomp.c++/reduction-11.C /^foo (int (*&x)[3][2], int *y, long (&w)[1][2], int s, int t)$/;" f +foo testsuite/libgomp.c++/reduction-12.C /^S::foo (int p1, long p2, long p3, int p4, int p5, long p6, short p7, int s, int t)$/;" f class:S +foo testsuite/libgomp.c++/reduction-12.C /^foo (A (*&x)[3][N], M *y, B (&w)[1][N], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c++/reduction-4.C /^foo ()$/;" f +foo testsuite/libgomp.c++/reduction-5.C /^S::foo ()$/;" f class:S +foo testsuite/libgomp.c++/reduction-5.C /^foo (int (*&x)[3][2], int *y, long (&w)[1][2])$/;" f +foo testsuite/libgomp.c++/reduction-6.C /^S::foo ()$/;" f class:S +foo testsuite/libgomp.c++/reduction-6.C /^foo (A (*&x)[3][2], M *y, B (&w)[1][2])$/;" f +foo testsuite/libgomp.c++/reduction-7.C /^S::foo (int p1, long p2, long p3, int p4, int p5, long p6, short p7)$/;" f class:S +foo testsuite/libgomp.c++/reduction-7.C /^foo (int (*&x)[3][2], int *y, long (&w)[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c++/reduction-8.C /^S::foo (int p1, long p2, long p3, int p4, int p5, long p6, short p7)$/;" f class:S +foo testsuite/libgomp.c++/reduction-8.C /^foo (A (*&x)[3][2], M *y, B (&w)[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c++/reduction-9.C /^S::foo ()$/;" f class:S +foo testsuite/libgomp.c++/reduction-9.C /^foo (int (*&x)[3][N], int *y, long (&w)[1][N])$/;" f +foo testsuite/libgomp.c++/reference-1.C /^foo (int &a, short &d, char &g)$/;" f +foo testsuite/libgomp.c++/simd-1.C /^foo (int *p)$/;" f +foo testsuite/libgomp.c++/simd-2.C /^foo ()$/;" f +foo testsuite/libgomp.c++/simd-3.C /^foo (int *p)$/;" f +foo testsuite/libgomp.c++/simd-4.C /^foo ()$/;" f +foo testsuite/libgomp.c++/simd-5.C /^foo ()$/;" f +foo testsuite/libgomp.c++/simd-6.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/simd-7.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/simd-8.C /^foo ()$/;" f +foo testsuite/libgomp.c++/simd-9.C /^foo (int &u, int &v)$/;" f +foo testsuite/libgomp.c++/simd14.C /^foo (unsigned long long &s, short *&t)$/;" f +foo testsuite/libgomp.c++/target-10.C /^foo ()$/;" f +foo testsuite/libgomp.c++/target-11.C /^foo ()$/;" f +foo testsuite/libgomp.c++/target-12.C /^foo ()$/;" f +foo testsuite/libgomp.c++/target-13.C /^foo (void)$/;" f +foo testsuite/libgomp.c++/target-14.C /^foo (int &a, int (&b)[10], short &c, long (&d)[5], int n)$/;" f +foo testsuite/libgomp.c++/target-15.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/target-16.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/target-17.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/target-18.C /^foo (int *&p, int *&q, int *&r, int n, int m)$/;" f +foo testsuite/libgomp.c++/target-19.C /^foo (S s, int (&t)[3], int z)$/;" f +foo testsuite/libgomp.c++/target-20.C /^foo (S &s)$/;" f +foo testsuite/libgomp.c++/target-21.C /^foo (S s)$/;" f +foo testsuite/libgomp.c++/target-6.C /^foo (int &x, int &y, S &u, S &v, double &s, double &t)$/;" f +foo testsuite/libgomp.c++/target-7.C /^foo (int *x, int *&y, int (&z)[15])$/;" f +foo testsuite/libgomp.c++/target-8.C /^foo (T a, int b, struct S c)$/;" f +foo testsuite/libgomp.c++/target-9.C /^foo (int *&p, int (&s)[5], int n)$/;" f +foo testsuite/libgomp.c++/task-2.C /^foo (int i)$/;" f +foo testsuite/libgomp.c++/task-3.C /^foo (int i)$/;" f +foo testsuite/libgomp.c++/task-4.C /^foo (int i, int j)$/;" f +foo testsuite/libgomp.c++/task-5.C /^foo (int i)$/;" f +foo testsuite/libgomp.c++/task-7.C /^ void foo() { }$/;" f struct:A +foo testsuite/libgomp.c++/taskloop-5.C /^foo (int &b)$/;" f +foo testsuite/libgomp.c++/udr-1.C /^ void foo (S &x) { s += x.s; }$/;" f struct:S +foo testsuite/libgomp.c++/udr-1.C /^ void foo (S &x, bool y) { s += x.s; if (y) abort (); }$/;" f struct:S +foo testsuite/libgomp.c++/udr-2.C /^ void foo (S &x) { s += x.s; }$/;" f struct:NS::S +foo testsuite/libgomp.c++/udr-2.C /^ void foo (S &x, bool y) { s += x.s; if (y) abort (); }$/;" f struct:NS::S +foo testsuite/libgomp.c++/udr-3.C /^ void foo (S &x) { s += x.s; }$/;" f struct:NS::S +foo testsuite/libgomp.c++/udr-3.C /^ void foo (S &x, bool y) { s += x.s; if (y) abort (); }$/;" f struct:NS::S +foo testsuite/libgomp.c++/udr-5.C /^ void foo ()$/;" f struct:S +foo testsuite/libgomp.c++/udr-5.C /^ void foo ()$/;" f struct:T +foo testsuite/libgomp.c++/udr-6.C /^foo (B &x)$/;" f +foo testsuite/libgomp.c++/udr-7.C /^ void foo (S &x) { s += x.s; }$/;" f struct:S +foo testsuite/libgomp.c++/udr-8.C /^foo (S *x, S *y)$/;" f +foo testsuite/libgomp.c/atomic-12.c /^foo (void)$/;" f +foo testsuite/libgomp.c/atomic-13.c /^foo (void)$/;" f +foo testsuite/libgomp.c/atomic-14.c /^foo (void)$/;" f +foo testsuite/libgomp.c/atomic-16.c /^foo (void)$/;" f +foo testsuite/libgomp.c/atomic-3.c /^foo (int x, long long y)$/;" f +foo testsuite/libgomp.c/autopar-1.c /^foo (void)$/;" f +foo testsuite/libgomp.c/cancel-for-2.c /^foo (int *x)$/;" f +foo testsuite/libgomp.c/cancel-parallel-2.c /^foo (int *x)$/;" f file: +foo testsuite/libgomp.c/depend-2.c /^foo (int do_sleep)$/;" f +foo testsuite/libgomp.c/examples-4/array_sections-3.c /^void foo ()$/;" f +foo testsuite/libgomp.c/examples-4/array_sections-4.c /^void foo ()$/;" f +foo testsuite/libgomp.c/examples-4/simd-6.c /^int foo(int *p){$/;" f +foo testsuite/libgomp.c/examples-4/target_data-4.c /^void foo (double *p0, double *v1, double *v2, int N)$/;" f +foo testsuite/libgomp.c/loop-8.c /^foo (void)$/;" f +foo testsuite/libgomp.c/nestedfn-5.c /^foo (int *j)$/;" f +foo testsuite/libgomp.c/omp-loop03.c /^foo ()$/;" f +foo testsuite/libgomp.c/omp-nested-1.c /^int foo()$/;" f +foo testsuite/libgomp.c/omp-parallel-if.c /^foo (void)$/;" f +foo testsuite/libgomp.c/ordered-4.c /^foo (int i, char *j)$/;" f +foo testsuite/libgomp.c/pr30494.c /^foo (int n, int m)$/;" f +foo testsuite/libgomp.c/pr36802-1.c /^foo (int k)$/;" f +foo testsuite/libgomp.c/pr36802-2.c /^foo (int k)$/;" f +foo testsuite/libgomp.c/pr36802-3.c /^foo (int k)$/;" f +foo testsuite/libgomp.c/pr39591-2.c /^foo (int *array)$/;" f +foo testsuite/libgomp.c/pr39591-3.c /^foo (int *array)$/;" f +foo testsuite/libgomp.c/pr45784.c /^foo (int n)$/;" f +foo testsuite/libgomp.c/pr46193.c /^foo (int count, char **list)$/;" f +foo testsuite/libgomp.c/pr46886.c /^int foo (void)$/;" f +foo testsuite/libgomp.c/pr52547.c /^foo (int x, int *y)$/;" f +foo testsuite/libgomp.c/pr58392.c /^foo (int a, int b)$/;" f +foo testsuite/libgomp.c/pr58756.c /^foo (int a, int b)$/;" f +foo testsuite/libgomp.c/pr61200.c /^foo ()$/;" f +foo testsuite/libgomp.c/pr64734.c /^foo (int *x, int *y)$/;" f +foo testsuite/libgomp.c/pr64868.c /^foo ()$/;" f +foo testsuite/libgomp.c/pr66133.c /^foo (void)$/;" f +foo testsuite/libgomp.c/pr69110.c /^foo (void)$/;" f file: +foo testsuite/libgomp.c/pr80809-1.c /^foo (int x)$/;" f +foo testsuite/libgomp.c/pr80809-2.c /^foo (int x)$/;" f +foo testsuite/libgomp.c/pr80809-3.c /^foo (int x)$/;" f +foo testsuite/libgomp.c/pr80853.c /^foo (int *p)$/;" f +foo testsuite/libgomp.c/reduction-10.c /^foo (struct A (*x)[3][2], struct A *y, struct D w[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c/reduction-11.c /^foo (int (*x)[3][2], int *y, long w[1][2], int s, int t)$/;" f +foo testsuite/libgomp.c/reduction-12.c /^foo (struct A (*x)[3][2], struct A *y, struct D w[1][2], int s, int t)$/;" f +foo testsuite/libgomp.c/reduction-13.c /^foo (int (*x)[3][2], int *y, long w[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c/reduction-14.c /^foo (struct A (*x)[3][2], struct A *y, struct D w[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c/reduction-15.c /^foo (int x, int y)$/;" f +foo testsuite/libgomp.c/reduction-7.c /^foo (int (*x)[3][2], int *y, long w[1][2])$/;" f +foo testsuite/libgomp.c/reduction-8.c /^foo (struct A (*x)[3][2], struct A *y, struct D w[1][2])$/;" f +foo testsuite/libgomp.c/reduction-9.c /^foo (int (*x)[3][2], int *y, long w[1][2], int p1, long p2, long p3, int p4,$/;" f +foo testsuite/libgomp.c/sections-2.c /^foo ()$/;" f +foo testsuite/libgomp.c/simd-1.c /^foo (int *p)$/;" f +foo testsuite/libgomp.c/simd-10.c /^foo ()$/;" f +foo testsuite/libgomp.c/simd-11.c /^foo ()$/;" f +foo testsuite/libgomp.c/simd-15.c /^foo (int *b, int *i, int *j, int x)$/;" f file: +foo testsuite/libgomp.c/simd-17.c /^foo (int *b, int *i, int *j, int x)$/;" f file: +foo testsuite/libgomp.c/simd-2.c /^foo ()$/;" f +foo testsuite/libgomp.c/simd-3.c /^foo (int *p)$/;" f +foo testsuite/libgomp.c/simd-4.c /^foo (void)$/;" f +foo testsuite/libgomp.c/simd-5.c /^foo (void)$/;" f +foo testsuite/libgomp.c/simd-6.c /^foo (void)$/;" f +foo testsuite/libgomp.c/simd-7.c /^foo (int *p)$/;" f +foo testsuite/libgomp.c/simd-8.c /^foo (void)$/;" f +foo testsuite/libgomp.c/simd-9.c /^foo (void)$/;" f +foo testsuite/libgomp.c/target-13.c /^foo ()$/;" f +foo testsuite/libgomp.c/target-15.c /^foo (int *x)$/;" f +foo testsuite/libgomp.c/target-16.c /^foo (int n)$/;" f +foo testsuite/libgomp.c/target-17.c /^foo (int n)$/;" f +foo testsuite/libgomp.c/target-18.c /^foo (int n)$/;" f +foo testsuite/libgomp.c/target-19.c /^foo (int *p, int *q, int *r, int n, int m)$/;" f +foo testsuite/libgomp.c/target-28.c /^foo (void)$/;" f +foo testsuite/libgomp.c/target-29.c /^foo (struct S s)$/;" f +foo testsuite/libgomp.c/target-35.c /^foo (int x, int y, int z, int *a, int *b)$/;" f +foo testsuite/libgomp.c/target-7.c /^foo (int f)$/;" f +foo testsuite/libgomp.c/target-8.c /^foo (int *p)$/;" f +foo testsuite/libgomp.c/target-9.c /^foo ()$/;" f +foo testsuite/libgomp.c/target-critical-1.c /^int foo ()$/;" f +foo testsuite/libgomp.c/target-link-1.c /^foo (void)$/;" f +foo testsuite/libgomp.c/target-teams-1.c /^foo (int a, int b, long c, long d)$/;" f +foo testsuite/libgomp.c/task-3.c /^foo (int i)$/;" f +foo testsuite/libgomp.c/task-4.c /^foo (int i, int j)$/;" f +foo testsuite/libgomp.c/taskloop-1.c /^foo (long a, long b)$/;" f +foo testsuite/libgomp.c/udr-1.c /^foo (struct S *out, struct S *in)$/;" f +foo testsuite/libgomp.c/udr-3.c /^foo (struct S *x, struct S *y)$/;" f +foo testsuite/libgomp.fortran/alloc-comp-1.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/alloc-comp-2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/alloc-comp-3.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/cancel-do-2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/declare-simd-1.f90 /^ real function foo /;" f module:declare_simd_1_mod +foo testsuite/libgomp.fortran/declare-simd-2.f90 /^ real function foo /;" f module:declare_simd_2_mod +foo testsuite/libgomp.fortran/declare-target-2.f90 /^subroutine foo$/;" s +foo testsuite/libgomp.fortran/depend-3.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/examples-4/array_sections-3.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/examples-4/array_sections-4.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function foo(/;" f module:SIMD6_mod +foo testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ subroutine foo /;" s module:e_51_4_mod +foo testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ subroutine foo /;" s module:e_51_5_mod +foo testsuite/libgomp.fortran/nestedfn1.f90 /^ subroutine foo$/;" s +foo testsuite/libgomp.fortran/nestedfn3.f90 /^ subroutine foo /;" s program:nestomp +foo testsuite/libgomp.fortran/nestedfn4.f90 /^program foo$/;" p +foo testsuite/libgomp.fortran/nestedfn5.f90 /^ subroutine foo$/;" s subroutine:bar +foo testsuite/libgomp.fortran/omp_atomic2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^subroutine foo /;" s +foo testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^subroutine foo /;" s +foo testsuite/libgomp.fortran/pointer1.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/pr27395-1.f90 /^subroutine foo(/;" s +foo testsuite/libgomp.fortran/pr27395-2.f90 /^subroutine foo(/;" s +foo testsuite/libgomp.fortran/pr27416-1.f90 /^subroutine foo /;" s +foo testsuite/libgomp.fortran/procptr1.f90 /^integer function foo /;" f +foo testsuite/libgomp.fortran/reduction6.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/reference2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/simd2.f90 /^ function foo /;" f +foo testsuite/libgomp.fortran/simd3.f90 /^ function foo /;" f +foo testsuite/libgomp.fortran/simd4.f90 /^ function foo /;" f +foo testsuite/libgomp.fortran/simd6.f90 /^subroutine foo /;" s +foo testsuite/libgomp.fortran/simd7.f90 /^subroutine foo /;" s +foo testsuite/libgomp.fortran/stack.f90 /^ integer omp_get_thread_num, foo$/;" v program:stack +foo testsuite/libgomp.fortran/stack.f90 /^integer function foo /;" f +foo testsuite/libgomp.fortran/target1.f90 /^ subroutine foo /;" s module:target1 +foo testsuite/libgomp.fortran/target2.f90 /^ subroutine foo /;" s module:target2 +foo testsuite/libgomp.fortran/target3.f90 /^ subroutine foo /;" s module:target3 +foo testsuite/libgomp.fortran/target4.f90 /^ subroutine foo /;" s module:target4 +foo testsuite/libgomp.fortran/target5.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/target6.f90 /^ subroutine foo /;" s module:target6 +foo testsuite/libgomp.fortran/target7.f90 /^real function foo /;" f +foo testsuite/libgomp.fortran/target8.f90 /^ real function foo /;" f +foo testsuite/libgomp.fortran/task2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/taskloop1.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/threadprivate2.f90 /^ integer, dimension(:,:), allocatable :: foo$/;" v module:threadprivate2 +foo testsuite/libgomp.fortran/threadprivate3.f90 /^ integer, dimension(:,:), pointer :: foo /;" v module:threadprivate3 +foo testsuite/libgomp.fortran/udr14.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla1.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla2.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla3.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla4.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla5.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla6.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/vla8.f90 /^ subroutine foo /;" s +foo testsuite/libgomp.fortran/workshare1.f90 /^ integer :: a (10), b (10), foo,/;" v +foo testsuite/libgomp.fortran/workshare1.f90 /^function foo /;" f +foo testsuite/libgomp.graphite/bounds.c /^int foo(int *a, int n)$/;" f +foo testsuite/libgomp.graphite/force-parallel-3.c /^void foo(void)$/;" f +foo testsuite/libgomp.graphite/force-parallel-4.c /^void foo(void)$/;" f +foo testsuite/libgomp.graphite/force-parallel-5.c /^void foo(void)$/;" f +foo testsuite/libgomp.graphite/force-parallel-6.c /^foo (void)$/;" f file: +foo testsuite/libgomp.graphite/force-parallel-7.c /^int foo (void)$/;" f +foo testsuite/libgomp.graphite/force-parallel-8.c /^int foo(void)$/;" f +foo testsuite/libgomp.graphite/force-parallel-9.c /^void foo(void)$/;" f +foo testsuite/libgomp.graphite/pr41118.c /^void foo(int *a, int *b)$/;" f +foo testsuite/libgomp.hsa.c/formal-actual-args-1.c /^foo (short a)$/;" f +foo testsuite/libgomp.hsa.c/gridify-1.c /^foo (int n, int *a, int workgroup_size)$/;" f +foo testsuite/libgomp.hsa.c/gridify-2.c /^foo (int j, int n, int *a)$/;" f +foo testsuite/libgomp.hsa.c/gridify-3.c /^foo (int j, int n, int *a)$/;" f +foo testsuite/libgomp.hsa.c/gridify-4.c /^foo (int j, int n, int *a)$/;" f +foo testsuite/libgomp.hsa.c/pr69568.c /^foo (int n, float2 *a, int workgroup_size)$/;" f +foo testsuite/libgomp.hsa.c/switch-sbr-2.c /^foo (unsigned a)$/;" f +foo testsuite/libgomp.oacc-c++/declare-1.C /^T foo()$/;" f +foo testsuite/libgomp.oacc-c-c++-common/host_data-2.c /^void foo (char *in)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-2.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-3.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-4.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-5.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-6.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq.c /^foo (int n, unsigned int *a)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-collapse.c /^foo (int m, int n)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/kernels-loop-n.c /^foo (COUNTERTYPE n)$/;" f file: +foo testsuite/libgomp.oacc-c-c++-common/kernels-reduction.c /^foo (void)$/;" f +foo testsuite/libgomp.oacc-c-c++-common/pr70373.c /^foo (unsigned int sum)$/;" f +foo testsuite/libgomp.oacc-fortran/pr68813.f90 /^program foo$/;" p +foo testsuite/libgomp.oacc-fortran/pr70289.f90 /^program foo$/;" p +foo2 testsuite/libgomp.c++/target-21.C /^foo2 (S &s)$/;" f +foo2 testsuite/libgomp.c/pr46193.c /^foo2 (int count, char **list)$/;" f +foo3 testsuite/libgomp.c++/target-21.C /^foo3 (U s)$/;" f +foo4 testsuite/libgomp.c++/target-21.C /^foo4 (U &s)$/;" f +foo_ref testsuite/libgomp.c/examples-4/target_data-4.c /^void foo_ref (double *p0, double *v1, double *v2, int N)$/;" f +foo_seen testsuite/libgomp.fortran/workshare1.f90 /^ logical :: foo_seen,/;" v +foo_seen testsuite/libgomp.fortran/workshare1.f90 17;" c +foo_seen testsuite/libgomp.fortran/workshare1.f90 4;" c function:foo +format plugin/hsa_ext_finalize.h /^ hsa_ext_image_format_t format;$/;" m struct:hsa_ext_image_descriptor_s +fputc config/nvptx/error.c 36;" d file: +fputc config/nvptx/error.c 40;" d file: +fputs config/nvptx/error.c 35;" d file: +fputs config/nvptx/error.c 39;" d file: +fr testsuite/libgomp.c++/target-2-aux.cc /^double (&fr) [1024] = f;$/;" v +free_data tdg.c /^static inline void free_data (struct data_to_free *start)$/;" f file: +free_func libgomp.h /^ __typeof (GOMP_OFFLOAD_free) *free_func;$/;" m struct:gomp_device_descr +free_hash tdg.c /^static void free_hash ()$/;" f file: +free_team team.c /^free_team (struct gomp_team *team)$/;" f file: +free_work_share work.c /^free_work_share (struct gomp_team *team, struct gomp_work_share *ws)$/;" f file: +ftmp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ real fgot, fexp, ftmp$/;" v program:main +func testsuite/libgomp.fortran/pr29629.f90 /^ funct/;" f program:pr29629 +func testsuite/libgomp.oacc-c-c++-common/declare-4.c /^func (int a)$/;" f +func testsuite/libgomp.oacc-fortran/routine-5.f90 /^ funct/;" f program:main +func_append configure /^func_append ()$/;" f +func_arith configure /^func_arith ()$/;" f +func_basename configure /^func_basename ()$/;" f +func_dirname configure /^func_dirname ()$/;" f +func_dirname_and_basename configure /^func_dirname_and_basename ()$/;" f +func_echo_all configure /^func_echo_all ()$/;" f +func_fallback_echo configure /^ func_fallback_echo ()$/;" f +func_fallback_echo configure /^func_fallback_echo ()$/;" f +func_len configure /^func_len ()$/;" f +func_lo2o configure /^func_lo2o ()$/;" f +func_opt_split configure /^func_opt_split ()$/;" f +func_pointer tdg.h /^ void *func_pointer;$/;" m struct:tdg_func_hash_entry +func_stripname configure /^func_stripname ()$/;" f +func_xform configure /^func_xform ()$/;" f +function testsuite/libgomp.c/barrier-1.c /^static void function(void *dummy)$/;" f file: +function testsuite/libgomp.c/critical-1.c /^static void function(void *dummy)$/;" f file: +function testsuite/libgomp.c/parallel-1.c /^static void function(void *dummy)$/;" f file: +futex config/rtems/bar.h /^ struct _Futex_Control futex;$/;" m struct:__anon43 typeref:struct:__anon43::_Futex_Control +futex_wait config/linux/alpha/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/ia64/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/mips/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/powerpc/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/s390/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/sparc/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/tile/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/linux/x86/futex.h /^futex_wait (int *addr, int val)$/;" f +futex_wait config/rtems/bar.c /^futex_wait (int *addr, int val)$/;" f file: +futex_wake config/linux/alpha/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/ia64/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/mips/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/powerpc/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/s390/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/sparc/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/tile/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/linux/x86/futex.h /^futex_wake (int *addr, int count)$/;" f +futex_wake config/rtems/bar.c /^futex_wake (int *addr, int count)$/;" f file: +g testsuite/libgomp.c++/target-13.C /^int g;$/;" v +g testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +g testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +g testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +g testsuite/libgomp.c++/target-2-aux.cc /^double *g = gbuf;$/;" v +g testsuite/libgomp.c/appendix-a/a.19.1.c /^g (int n)$/;" f +g testsuite/libgomp.c/atomic-3.c /^int g;$/;" v +g testsuite/libgomp.c/autopar-1.c /^int f[1024], g[1024];$/;" v +g testsuite/libgomp.c/doacross-2.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +g testsuite/libgomp.c/doacross-3.c /^int a[N], b[N \/ 16][8][4], c[N \/ 32][8][8], g[N \/ 16][8][6];$/;" v +g testsuite/libgomp.c/pr26943-2.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +g testsuite/libgomp.c/pr26943-3.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +g testsuite/libgomp.c/pr26943-4.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +g testsuite/libgomp.c/target-28.c /^int g;$/;" v +g testsuite/libgomp.c/target-31.c /^int e[2] = { 5, 6 }, f[2] = { 7, 8 }, g[2] = { 9, 10 }, h[2] = { 11, 12 };$/;" v +g testsuite/libgomp.c/taskloop-3.c /^int g;$/;" v +g testsuite/libgomp.fortran/alloc-comp-1.f90 /^ intege/;" k type:dt +g testsuite/libgomp.fortran/alloc-comp-2.f90 /^ intege/;" k type:dt +g testsuite/libgomp.fortran/alloc-comp-3.f90 /^ intege/;" k type:dt +g testsuite/libgomp.fortran/doacross2.f90 /^ intege/;" v +g testsuite/libgomp.fortran/doacross3.f90 /^ intege/;" v +g testsuite/libgomp.fortran/simd7.f90 /^ intege/;" v +g testsuite/libgomp.fortran/target2.f90 /^ intege/;" v +g testsuite/libgomp.fortran/target3.f90 /^ intege/;" v +g testsuite/libgomp.fortran/taskloop3.f90 /^ intege/;" v +g testsuite/libgomp.fortran/udr14.f90 /^ intege/;" k type:dt +g testsuite/libgomp.hsa.c/complex-align-2.c /^ _Complex int *g;$/;" v +g_np_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void g_np_1()$/;" f +g_sum testsuite/libgomp.c/uns-outer-4.c /^unsigned int g_sum = 1;$/;" v +gang testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^gang (Type ary[N], Type sum, Type prod)$/;" f file: +gang testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^gang (Type ary[N], Type sum, Type prod)$/;" f file: +gang testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^gang (Type ary[N], Type sum, Type prod)$/;" f file: +gang testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^gang (Type ary[N], Type sum, Type prod)$/;" f file: +gang testsuite/libgomp.oacc-c-c++-common/routine-4.c /^gang (int *a)$/;" f +gang testsuite/libgomp.oacc-c-c++-common/routine-g-1.c /^void __attribute__ ((noinline)) gang (int ary[N])$/;" f +gang testsuite/libgomp.oacc-c-c++-common/routine-gwv-1.c /^void __attribute__ ((noinline)) gang (int ary[N])$/;" f +gang testsuite/libgomp.oacc-fortran/routine-7.f90 /^subroutine gang /;" s program:main +gang_1 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int gang_1 (int *ary, int size)$/;" f +gang_2 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int gang_2 (int *ary, int size)$/;" f +gang_3 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int gang_3 (int *ary, int size)$/;" f +gang_4 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int gang_4 (int *ary, int size)$/;" f +gang_vector_1 testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_vector_1 (int *ary, int size)$/;" f +gang_vector_2a testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_vector_2a (int *ary, int size)$/;" f +gang_vector_2b testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_vector_2b (int *ary, int size)$/;" f +gang_worker_vector_2a testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_worker_vector_2a (int *ary, int size)$/;" f +gang_worker_vector_2b testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_worker_vector_2b (int *ary, int size)$/;" f +gang_worker_vector_star_2a testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_worker_vector_star_2a (int *ary, int size)$/;" f +gang_worker_vector_star_2b testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int gang_worker_vector_star_2b (int *ary, int size)$/;" f +gbuf testsuite/libgomp.c++/target-2-aux.cc /^double gbuf[1024];$/;" v +gdims plugin/plugin-hsa.c /^ uint32_t gdims[3];$/;" m struct:GOMP_kernel_launch_attributes file: +generation config/linux/bar.h /^ unsigned generation;$/;" m struct:__anon42 +generation config/nvptx/bar.h /^ unsigned generation;$/;" m struct:__anon39 +generation config/posix/bar.h /^ unsigned generation;$/;" m struct:__anon35 +generation config/rtems/bar.h /^ unsigned generation;$/;" m struct:__anon43 +generation_to_barrier config/rtems/bar.c /^generation_to_barrier (int *addr)$/;" f file: +geometry plugin/hsa_ext_finalize.h /^ hsa_ext_image_geometry_t geometry;$/;" m struct:hsa_ext_image_descriptor_s +get_agent_info plugin/plugin-hsa.c /^get_agent_info (int n)$/;" f file: +get_buf testsuite/libgomp.c/affinity-2.c /^get_buf (int nump)$/;" f +get_caps_func libgomp.h /^ __typeof (GOMP_OFFLOAD_get_caps) *get_caps_func;$/;" m struct:gomp_device_descr +get_current_context_func libgomp.h /^ *get_current_context_func;$/;" m struct:acc_dispatch_t::__anon52 +get_current_device_func libgomp.h /^ *get_current_device_func;$/;" m struct:acc_dispatch_t::__anon52 +get_group_size plugin/plugin-hsa.c /^get_group_size (uint32_t ndim, uint32_t grid, uint32_t group)$/;" f file: +get_kernarg_memory_region plugin/plugin-hsa.c /^get_kernarg_memory_region (hsa_region_t region, void *data)$/;" f file: +get_kernel_for_agent plugin/plugin-hsa.c /^get_kernel_for_agent (struct agent_info *agent, const char *kernel_name)$/;" f file: +get_kind target.c /^get_kind (bool short_mapkind, void *kinds, int idx)$/;" f file: +get_last_team team.c /^get_last_team (unsigned nthreads)$/;" f file: +get_name_func libgomp.h /^ __typeof (GOMP_OFFLOAD_get_name) *get_name_func;$/;" m struct:gomp_device_descr +get_nanosecs testsuite/libgomp.hsa.c/tiling-1.c /^long int get_nanosecs( struct timespec start_time, struct timespec end_time) {$/;" f +get_nanosecs testsuite/libgomp.hsa.c/tiling-2.c /^long int get_nanosecs( struct timespec start_time, struct timespec end_time) {$/;" f +get_num_devices_func libgomp.h /^ __typeof (GOMP_OFFLOAD_get_num_devices) *get_num_devices_func;$/;" m struct:gomp_device_descr +get_num_procs config/bsd/proc.c /^get_num_procs (void)$/;" f file: +get_num_procs config/linux/proc.c /^get_num_procs (void)$/;" f file: +get_openacc_name oacc-init.c /^get_openacc_name (const char *name)$/;" f file: +get_stream_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_cuda_get_stream) *get_stream_func;$/;" m struct:acc_dispatch_t::__anon52 +get_type_func libgomp.h /^ __typeof (GOMP_OFFLOAD_get_type) *get_type_func;$/;" m struct:gomp_device_descr +global_in_host testsuite/libgomp.oacc-c-c++-common/host_data-2.c /^char *global_in_host;$/;" v +global_var_info plugin/plugin-hsa.c /^struct global_var_info$/;" s file: +global_variable_count plugin/plugin-hsa.c /^ const unsigned global_variable_count;$/;" m struct:brig_image_desc file: +global_variables plugin/plugin-hsa.c /^ struct global_var_info *global_variables;$/;" m struct:brig_image_desc typeref:struct:brig_image_desc::global_var_info file: +globalvars testsuite/libgomp.oacc-fortran/declare-2.f90 /^module globalvars$/;" m +globalvars testsuite/libgomp.oacc-fortran/declare-3.f90 /^module globalvars$/;" m +goacc_attach_host_thread_to_device oacc-init.c /^goacc_attach_host_thread_to_device (int ord)$/;" f +goacc_cleanup_key oacc-init.c /^static pthread_key_t goacc_cleanup_key;$/;" v file: +goacc_destroy_thread oacc-init.c /^goacc_destroy_thread (void *data)$/;" f file: +goacc_device_num env.c /^int goacc_device_num;$/;" v +goacc_device_type env.c /^char *goacc_device_type;$/;" v +goacc_host_init oacc-host.c /^goacc_host_init (void)$/;" f +goacc_lazy_initialize oacc-init.c /^goacc_lazy_initialize (void)$/;" f +goacc_new_thread oacc-init.c /^goacc_new_thread (void)$/;" f file: +goacc_register oacc-init.c /^goacc_register (struct gomp_device_descr *disp)$/;" f +goacc_restore_bind oacc-init.c /^goacc_restore_bind (void)$/;" f +goacc_save_and_set_bind oacc-init.c /^goacc_save_and_set_bind (acc_device_t d)$/;" f +goacc_thread oacc-int.h /^goacc_thread (void)$/;" f +goacc_thread oacc-int.h /^struct goacc_thread$/;" s +goacc_thread_lock oacc-init.c /^static gomp_mutex_t goacc_thread_lock;$/;" v file: +goacc_threads oacc-init.c /^static struct goacc_thread *goacc_threads;$/;" v typeref:struct:goacc_thread file: +goacc_tls_data oacc-init.c /^__thread struct goacc_thread *goacc_tls_data;$/;" v typeref:struct:goacc_thread +goacc_tls_key oacc-init.c /^pthread_key_t goacc_tls_key;$/;" v +goacc_wait oacc-parallel.c /^goacc_wait (int async, int num_waits, va_list *ap)$/;" f file: +gomp_acc_insert_pointer oacc-mem.c /^gomp_acc_insert_pointer (size_t mapnum, void **hostaddrs, size_t *sizes,$/;" f +gomp_acc_remove_pointer oacc-mem.c /^gomp_acc_remove_pointer (void *h, bool force_copyfrom, int async, int mapnum)$/;" f +gomp_adjust_thread_attr config/posix/pool.h /^gomp_adjust_thread_attr (pthread_attr_t *attr, pthread_attr_t *mutable_attr)$/;" f +gomp_adjust_thread_attr config/rtems/pool.h /^gomp_adjust_thread_attr (pthread_attr_t *attr, pthread_attr_t *mutable_attr)$/;" f +gomp_affinity_add_cpus affinity.c /^gomp_affinity_add_cpus (void *p, unsigned long num,$/;" f +gomp_affinity_add_cpus config/linux/affinity.c /^gomp_affinity_add_cpus (void *p, unsigned long num,$/;" f +gomp_affinity_alloc affinity.c /^gomp_affinity_alloc (unsigned long count, bool quiet)$/;" f +gomp_affinity_alloc config/linux/affinity.c /^gomp_affinity_alloc (unsigned long count, bool quiet)$/;" f +gomp_affinity_copy_place affinity.c /^gomp_affinity_copy_place (void *p, void *q, long stride)$/;" f +gomp_affinity_copy_place config/linux/affinity.c /^gomp_affinity_copy_place (void *p, void *q, long stride)$/;" f +gomp_affinity_finalize_place_list affinity.c /^gomp_affinity_finalize_place_list (bool quiet)$/;" f +gomp_affinity_finalize_place_list config/linux/affinity.c /^gomp_affinity_finalize_place_list (bool quiet)$/;" f +gomp_affinity_init_level affinity.c /^gomp_affinity_init_level (int level, unsigned long count, bool quiet)$/;" f +gomp_affinity_init_level config/linux/affinity.c /^gomp_affinity_init_level (int level, unsigned long count, bool quiet)$/;" f +gomp_affinity_init_level_1 config/linux/affinity.c /^gomp_affinity_init_level_1 (int level, int this_level, unsigned long count,$/;" f file: +gomp_affinity_init_place affinity.c /^gomp_affinity_init_place (void *p)$/;" f +gomp_affinity_init_place config/linux/affinity.c /^gomp_affinity_init_place (void *p)$/;" f +gomp_affinity_print_place affinity.c /^gomp_affinity_print_place (void *p)$/;" f +gomp_affinity_print_place config/linux/affinity.c /^gomp_affinity_print_place (void *p)$/;" f +gomp_affinity_remove_cpu affinity.c /^gomp_affinity_remove_cpu (void *p, unsigned long num)$/;" f +gomp_affinity_remove_cpu config/linux/affinity.c /^gomp_affinity_remove_cpu (void *p, unsigned long num)$/;" f +gomp_affinity_same_place affinity.c /^gomp_affinity_same_place (void *p, void *q)$/;" f +gomp_affinity_same_place config/linux/affinity.c /^gomp_affinity_same_place (void *p, void *q)$/;" f +gomp_alloca libgomp.h 96;" d +gomp_available_cpus env.c /^unsigned long gomp_available_cpus = 1, gomp_managed_threads = 1;$/;" v +gomp_barrier_destroy config/linux/bar.h /^static inline void gomp_barrier_destroy (gomp_barrier_t *bar)$/;" f +gomp_barrier_destroy config/nvptx/bar.h /^static inline void gomp_barrier_destroy (gomp_barrier_t *bar)$/;" f +gomp_barrier_destroy config/posix/bar.c /^gomp_barrier_destroy (gomp_barrier_t *bar)$/;" f +gomp_barrier_destroy config/rtems/bar.h /^static inline void gomp_barrier_destroy (gomp_barrier_t *bar)$/;" f +gomp_barrier_handle_tasks task.c /^gomp_barrier_handle_tasks (gomp_barrier_state_t state)$/;" f +gomp_barrier_init config/linux/bar.h /^static inline void gomp_barrier_init (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_init config/nvptx/bar.h /^static inline void gomp_barrier_init (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_init config/posix/bar.c /^gomp_barrier_init (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_init config/rtems/bar.h /^static inline void gomp_barrier_init (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_last_thread config/linux/bar.h /^gomp_barrier_last_thread (gomp_barrier_state_t state)$/;" f +gomp_barrier_last_thread config/nvptx/bar.h /^gomp_barrier_last_thread (gomp_barrier_state_t state)$/;" f +gomp_barrier_last_thread config/posix/bar.h /^gomp_barrier_last_thread (gomp_barrier_state_t state)$/;" f +gomp_barrier_last_thread config/rtems/bar.h /^gomp_barrier_last_thread (gomp_barrier_state_t state)$/;" f +gomp_barrier_reinit config/linux/bar.h /^static inline void gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_reinit config/nvptx/bar.h /^static inline void gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_reinit config/posix/bar.c /^gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_reinit config/rtems/bar.h /^static inline void gomp_barrier_reinit (gomp_barrier_t *bar, unsigned count)$/;" f +gomp_barrier_state_t config/linux/bar.h /^typedef unsigned int gomp_barrier_state_t;$/;" t +gomp_barrier_state_t config/nvptx/bar.h /^typedef unsigned int gomp_barrier_state_t;$/;" t +gomp_barrier_state_t config/posix/bar.h /^typedef unsigned int gomp_barrier_state_t;$/;" t +gomp_barrier_state_t config/rtems/bar.h /^typedef unsigned int gomp_barrier_state_t;$/;" t +gomp_barrier_t config/linux/bar.h /^} gomp_barrier_t;$/;" t typeref:struct:__anon42 +gomp_barrier_t config/nvptx/bar.h /^} gomp_barrier_t;$/;" t typeref:struct:__anon39 +gomp_barrier_t config/posix/bar.h /^} gomp_barrier_t;$/;" t typeref:struct:__anon35 +gomp_barrier_t config/rtems/bar.h /^} gomp_barrier_t;$/;" t typeref:struct:__anon43 +gomp_barrier_wait config/linux/bar.c /^gomp_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait config/nvptx/bar.c /^gomp_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait config/posix/bar.c /^gomp_barrier_wait (gomp_barrier_t *barrier)$/;" f +gomp_barrier_wait config/rtems/bar.c /^gomp_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_cancel_start config/linux/bar.h /^gomp_barrier_wait_cancel_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_cancel_start config/nvptx/bar.h /^gomp_barrier_wait_cancel_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_cancel_start config/posix/bar.h /^gomp_barrier_wait_cancel_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_cancel_start config/rtems/bar.h /^gomp_barrier_wait_cancel_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_end config/linux/bar.c /^gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_barrier_wait_end config/nvptx/bar.c /^gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_barrier_wait_end config/posix/bar.c /^gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_barrier_wait_end config/rtems/bar.c /^gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_barrier_wait_final_start config/linux/bar.h /^gomp_barrier_wait_final_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_final_start config/nvptx/bar.h /^gomp_barrier_wait_final_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_final_start config/rtems/bar.h /^gomp_barrier_wait_final_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_last config/linux/bar.c /^gomp_barrier_wait_last (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_last config/nvptx/bar.c /^gomp_barrier_wait_last (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_last config/posix/bar.h /^gomp_barrier_wait_last (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_last config/rtems/bar.c /^gomp_barrier_wait_last (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_start config/linux/bar.h /^gomp_barrier_wait_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_start config/nvptx/bar.h /^gomp_barrier_wait_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_start config/posix/bar.h /^gomp_barrier_wait_start (gomp_barrier_t *bar)$/;" f +gomp_barrier_wait_start config/rtems/bar.h /^gomp_barrier_wait_start (gomp_barrier_t *bar)$/;" f +gomp_bind_var_list env.c /^char *gomp_bind_var_list;$/;" v +gomp_bind_var_list_len env.c /^unsigned long gomp_bind_var_list_len;$/;" v +gomp_cancel_kind libgomp.h /^enum gomp_cancel_kind$/;" g +gomp_cancel_var env.c /^bool gomp_cancel_var = false;$/;" v +gomp_clear_parent task.c /^gomp_clear_parent (struct priority_queue *q)$/;" f file: +gomp_clear_parent_in_list task.c /^gomp_clear_parent_in_list (struct priority_list *list)$/;" f file: +gomp_clear_parent_in_tree task.c /^gomp_clear_parent_in_tree (prio_splay_tree sp, prio_splay_tree_node node)$/;" f file: +gomp_copy_dev2host target.c /^gomp_copy_dev2host (struct gomp_device_descr *devicep,$/;" f file: +gomp_copy_host2dev target.c /^gomp_copy_host2dev (struct gomp_device_descr *devicep,$/;" f file: +gomp_cpuset_popcount config/linux/proc.c /^gomp_cpuset_popcount (unsigned long cpusetsize, cpu_set_t *cpusetp)$/;" f +gomp_cpuset_size config/linux/proc.c /^unsigned long gomp_cpuset_size;$/;" v +gomp_cpusetp config/linux/proc.c /^cpu_set_t *gomp_cpusetp;$/;" v +gomp_create_target_task task.c /^gomp_create_target_task (struct gomp_device_descr *devicep,$/;" f +gomp_data_store tdg.h /^struct gomp_data_store$/;" s +gomp_debug error.c /^gomp_debug (int kind, const char *msg, ...)$/;" f +gomp_debug error.c 47;" d file: +gomp_debug libgomp.h 108;" d +gomp_debug_var env.c /^int gomp_debug_var;$/;" v +gomp_dependers_vec libgomp.h /^struct gomp_dependers_vec$/;" s +gomp_destroy_lock_25 config/posix/lock.c /^gomp_destroy_lock_25 (omp_lock_25_t *lock)$/;" f +gomp_destroy_lock_30 config/posix/lock.c /^gomp_destroy_lock_30 (omp_lock_t *lock)$/;" f +gomp_destroy_lock_30 libgomp.h 1110;" d +gomp_destroy_lock_30 lock.c /^gomp_destroy_lock_30 (omp_lock_t *lock)$/;" f +gomp_destroy_lock__25 fortran.c /^gomp_destroy_lock__25 (omp_lock_25_arg_t lock)$/;" f +gomp_destroy_lock__30 fortran.c /^gomp_destroy_lock__30 (omp_lock_arg_t lock)$/;" f +gomp_destroy_lock__30 fortran.c 89;" d file: +gomp_destroy_nest_lock_25 config/linux/lock.c /^gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_destroy_nest_lock_25 config/posix/lock.c /^gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_destroy_nest_lock_30 config/posix/lock.c /^gomp_destroy_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_destroy_nest_lock_30 libgomp.h 1115;" d +gomp_destroy_nest_lock_30 lock.c /^gomp_destroy_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_destroy_nest_lock__25 fortran.c /^gomp_destroy_nest_lock__25 (omp_nest_lock_25_arg_t lock)$/;" f +gomp_destroy_nest_lock__30 fortran.c /^gomp_destroy_nest_lock__30 (omp_nest_lock_arg_t lock)$/;" f +gomp_destroy_nest_lock__30 fortran.c 94;" d file: +gomp_device_copy target.c /^gomp_device_copy (struct gomp_device_descr *devicep,$/;" f file: +gomp_device_descr libgomp.h /^struct gomp_device_descr$/;" s +gomp_device_state libgomp.h /^enum gomp_device_state$/;" g +gomp_doacross_init ordered.c /^gomp_doacross_init (unsigned ncounts, long *counts, long chunk_size)$/;" f +gomp_doacross_ull_init ordered.c /^gomp_doacross_ull_init (unsigned ncounts, gomp_ull *counts, gomp_ull chunk_size)$/;" f +gomp_doacross_work_share libgomp.h /^struct gomp_doacross_work_share$/;" s +gomp_dynamic_max_threads config/bsd/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_dynamic_max_threads config/linux/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_dynamic_max_threads config/mingw32/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_dynamic_max_threads config/nvptx/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_dynamic_max_threads config/posix/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_dynamic_max_threads config/rtems/proc.c /^gomp_dynamic_max_threads (void)$/;" f +gomp_end_task task.c /^gomp_end_task (void)$/;" f +gomp_error error.c /^gomp_error (const char *fmt, ...)$/;" f +gomp_exit_data target.c /^gomp_exit_data (struct gomp_device_descr *devicep, size_t mapnum,$/;" f file: +gomp_fatal error.c /^gomp_fatal (const char *fmt, ...)$/;" f +gomp_fini_work_share work.c /^gomp_fini_work_share (struct gomp_work_share *ws)$/;" f +gomp_finish_task libgomp.h /^gomp_finish_task (struct gomp_task *task)$/;" f +gomp_free_device_memory target.c /^gomp_free_device_memory (struct gomp_device_descr *devicep, void *devptr)$/;" f file: +gomp_free_memmap target.c /^gomp_free_memmap (struct splay_tree_s *mem_map)$/;" f +gomp_free_pool_helper team.c /^gomp_free_pool_helper (void *thread_pool)$/;" f file: +gomp_free_thread team.c /^gomp_free_thread (void *arg __attribute__((unused)))$/;" f +gomp_futex_wait config/linux/mutex.c /^int gomp_futex_wait = FUTEX_WAIT | FUTEX_PRIVATE_FLAG;$/;" v +gomp_futex_wake config/linux/mutex.c /^int gomp_futex_wake = FUTEX_WAKE | FUTEX_PRIVATE_FLAG;$/;" v +gomp_gen_task_run_pre task.c /^gomp_gen_task_run_pre (union task_union_t *task_u, struct gomp_team *team, int is_static)$/;" f file: +gomp_get_cpuset_size config/linux/proc.c /^static unsigned long gomp_get_cpuset_size;$/;" v file: +gomp_get_num_devices target.c /^gomp_get_num_devices (void)$/;" f +gomp_get_own_thread_pool config/rtems/pool.h /^gomp_get_own_thread_pool (struct gomp_thread *thr, unsigned nthreads)$/;" f +gomp_get_place_proc_ids_8 affinity.c /^gomp_get_place_proc_ids_8 (int place_num, int64_t *ids)$/;" f +gomp_get_place_proc_ids_8 config/linux/affinity.c /^gomp_get_place_proc_ids_8 (int place_num, int64_t *ids)$/;" f +gomp_get_target_fn_addr target.c /^gomp_get_target_fn_addr (struct gomp_device_descr *devicep,$/;" f file: +gomp_get_tdg tdg.c /^struct gomp_tdg_node *gomp_get_tdg(unsigned int task_instance_id)$/;" f +gomp_get_thread_pool config/nvptx/pool.h /^gomp_get_thread_pool (struct gomp_thread *thr, unsigned nthreads)$/;" f +gomp_get_thread_pool config/posix/pool.h /^gomp_get_thread_pool (struct gomp_thread *thr, unsigned nthreads)$/;" f +gomp_get_thread_pool config/rtems/pool.h /^gomp_get_thread_pool (struct gomp_thread *thr, unsigned nthreads)$/;" f +gomp_get_thread_pool_reservoir config/rtems/pool.h /^gomp_get_thread_pool_reservoir (void)$/;" f +gomp_global_icv env.c /^struct gomp_task_icv gomp_global_icv = {$/;" v typeref:struct:gomp_task_icv +gomp_icv libgomp.h /^static inline struct gomp_task_icv *gomp_icv (bool write)$/;" f +gomp_init_affinity affinity.c /^gomp_init_affinity (void)$/;" f +gomp_init_affinity config/linux/affinity.c /^gomp_init_affinity (void)$/;" f +gomp_init_device target.c /^gomp_init_device (struct gomp_device_descr *devicep)$/;" f +gomp_init_lock_25 config/posix/lock.c /^gomp_init_lock_25 (omp_lock_25_t *lock)$/;" f +gomp_init_lock_30 config/posix/lock.c /^gomp_init_lock_30 (omp_lock_t *lock)$/;" f +gomp_init_lock_30 libgomp.h 1109;" d +gomp_init_lock_30 lock.c /^gomp_init_lock_30 (omp_lock_t *lock)$/;" f +gomp_init_lock__25 fortran.c /^gomp_init_lock__25 (omp_lock_25_arg_t lock)$/;" f +gomp_init_lock__30 fortran.c 88;" d file: +gomp_init_nest_lock_25 config/linux/lock.c /^gomp_init_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_init_nest_lock_25 config/posix/lock.c /^gomp_init_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_init_nest_lock_30 config/posix/lock.c /^gomp_init_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_init_nest_lock_30 libgomp.h 1114;" d +gomp_init_nest_lock_30 lock.c /^gomp_init_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_init_nest_lock__25 fortran.c /^gomp_init_nest_lock__25 (omp_nest_lock_25_arg_t lock)$/;" f +gomp_init_nest_lock__30 fortran.c /^gomp_init_nest_lock__30 (omp_nest_lock_arg_t lock)$/;" f +gomp_init_nest_lock__30 fortran.c 93;" d file: +gomp_init_num_threads config/bsd/proc.c /^gomp_init_num_threads (void)$/;" f +gomp_init_num_threads config/linux/proc.c /^gomp_init_num_threads (void)$/;" f +gomp_init_num_threads config/mingw32/proc.c /^gomp_init_num_threads (void)$/;" f +gomp_init_num_threads config/posix/proc.c /^gomp_init_num_threads (void)$/;" f +gomp_init_num_threads config/rtems/proc.c /^gomp_init_num_threads (void)$/;" f +gomp_init_targets_once target.c /^gomp_init_targets_once (void)$/;" f +gomp_init_task task.c /^gomp_init_task (struct gomp_task *task, struct gomp_task *parent_task,$/;" f +gomp_init_thread_affinity affinity.c /^gomp_init_thread_affinity (pthread_attr_t *attr, unsigned int place)$/;" f +gomp_init_thread_affinity config/linux/affinity.c /^gomp_init_thread_affinity (pthread_attr_t *attr, unsigned int place)$/;" f +gomp_init_work_share work.c /^gomp_init_work_share (struct gomp_work_share *ws, bool ordered,$/;" f +gomp_is_initialized target.c /^static pthread_once_t gomp_is_initialized = PTHREAD_ONCE_INIT;$/;" v file: +gomp_iter_dynamic_next iter.c /^gomp_iter_dynamic_next (long *pstart, long *pend)$/;" f +gomp_iter_dynamic_next_locked iter.c /^gomp_iter_dynamic_next_locked (long *pstart, long *pend)$/;" f +gomp_iter_guided_next iter.c /^gomp_iter_guided_next (long *pstart, long *pend)$/;" f +gomp_iter_guided_next_locked iter.c /^gomp_iter_guided_next_locked (long *pstart, long *pend)$/;" f +gomp_iter_static_next iter.c /^gomp_iter_static_next (long *pstart, long *pend)$/;" f +gomp_iter_ull_dynamic_next iter_ull.c /^gomp_iter_ull_dynamic_next (gomp_ull *pstart, gomp_ull *pend)$/;" f +gomp_iter_ull_dynamic_next_locked iter_ull.c /^gomp_iter_ull_dynamic_next_locked (gomp_ull *pstart, gomp_ull *pend)$/;" f +gomp_iter_ull_guided_next iter_ull.c /^gomp_iter_ull_guided_next (gomp_ull *pstart, gomp_ull *pend)$/;" f +gomp_iter_ull_guided_next_locked iter_ull.c /^gomp_iter_ull_guided_next_locked (gomp_ull *pstart, gomp_ull *pend)$/;" f +gomp_iter_ull_static_next iter_ull.c /^gomp_iter_ull_static_next (gomp_ull *pstart, gomp_ull *pend)$/;" f +gomp_load_image_to_device target.c /^gomp_load_image_to_device (struct gomp_device_descr *devicep, unsigned version,$/;" f file: +gomp_load_plugin_for_device target.c /^gomp_load_plugin_for_device (struct gomp_device_descr *device,$/;" f file: +gomp_loop_doacross_dynamic_start loop.c /^gomp_loop_doacross_dynamic_start (unsigned ncounts, long *counts,$/;" f file: +gomp_loop_doacross_guided_start loop.c /^gomp_loop_doacross_guided_start (unsigned ncounts, long *counts,$/;" f file: +gomp_loop_doacross_static_start loop.c /^gomp_loop_doacross_static_start (unsigned ncounts, long *counts,$/;" f file: +gomp_loop_dynamic_next loop.c /^gomp_loop_dynamic_next (long *istart, long *iend)$/;" f file: +gomp_loop_dynamic_start loop.c /^gomp_loop_dynamic_start (long start, long end, long incr, long chunk_size,$/;" f file: +gomp_loop_guided_next loop.c /^gomp_loop_guided_next (long *istart, long *iend)$/;" f file: +gomp_loop_guided_start loop.c /^gomp_loop_guided_start (long start, long end, long incr, long chunk_size,$/;" f file: +gomp_loop_init loop.c /^gomp_loop_init (struct gomp_work_share *ws, long start, long end, long incr,$/;" f file: +gomp_loop_ordered_dynamic_next loop.c /^gomp_loop_ordered_dynamic_next (long *istart, long *iend)$/;" f file: +gomp_loop_ordered_dynamic_start loop.c /^gomp_loop_ordered_dynamic_start (long start, long end, long incr,$/;" f file: +gomp_loop_ordered_guided_next loop.c /^gomp_loop_ordered_guided_next (long *istart, long *iend)$/;" f file: +gomp_loop_ordered_guided_start loop.c /^gomp_loop_ordered_guided_start (long start, long end, long incr,$/;" f file: +gomp_loop_ordered_static_next loop.c /^gomp_loop_ordered_static_next (long *istart, long *iend)$/;" f file: +gomp_loop_ordered_static_start loop.c /^gomp_loop_ordered_static_start (long start, long end, long incr,$/;" f file: +gomp_loop_static_next loop.c /^gomp_loop_static_next (long *istart, long *iend)$/;" f file: +gomp_loop_static_start loop.c /^gomp_loop_static_start (long start, long end, long incr, long chunk_size,$/;" f file: +gomp_loop_ull_doacross_dynamic_start loop_ull.c /^gomp_loop_ull_doacross_dynamic_start (unsigned ncounts, gomp_ull *counts,$/;" f file: +gomp_loop_ull_doacross_guided_start loop_ull.c /^gomp_loop_ull_doacross_guided_start (unsigned ncounts, gomp_ull *counts,$/;" f file: +gomp_loop_ull_doacross_static_start loop_ull.c /^gomp_loop_ull_doacross_static_start (unsigned ncounts, gomp_ull *counts,$/;" f file: +gomp_loop_ull_dynamic_next loop_ull.c /^gomp_loop_ull_dynamic_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_dynamic_start loop_ull.c /^gomp_loop_ull_dynamic_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_loop_ull_guided_next loop_ull.c /^gomp_loop_ull_guided_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_guided_start loop_ull.c /^gomp_loop_ull_guided_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_loop_ull_init loop_ull.c /^gomp_loop_ull_init (struct gomp_work_share *ws, bool up, gomp_ull start,$/;" f file: +gomp_loop_ull_ordered_dynamic_next loop_ull.c /^gomp_loop_ull_ordered_dynamic_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_ordered_dynamic_start loop_ull.c /^gomp_loop_ull_ordered_dynamic_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_loop_ull_ordered_guided_next loop_ull.c /^gomp_loop_ull_ordered_guided_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_ordered_guided_start loop_ull.c /^gomp_loop_ull_ordered_guided_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_loop_ull_ordered_static_next loop_ull.c /^gomp_loop_ull_ordered_static_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_ordered_static_start loop_ull.c /^gomp_loop_ull_ordered_static_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_loop_ull_static_next loop_ull.c /^gomp_loop_ull_static_next (gomp_ull *istart, gomp_ull *iend)$/;" f file: +gomp_loop_ull_static_start loop_ull.c /^gomp_loop_ull_static_start (bool up, gomp_ull start, gomp_ull end,$/;" f file: +gomp_malloc alloc.c /^gomp_malloc (size_t size)$/;" f +gomp_malloc_cleared alloc.c /^gomp_malloc_cleared (size_t size)$/;" f +gomp_managed_threads env.c /^unsigned long gomp_available_cpus = 1, gomp_managed_threads = 1;$/;" v +gomp_managed_threads_lock env.c /^gomp_mutex_t gomp_managed_threads_lock;$/;" v +gomp_map_0len_lookup target.c /^gomp_map_0len_lookup (splay_tree mem_map, splay_tree_key key)$/;" f file: +gomp_map_fields_existing target.c /^gomp_map_fields_existing (struct target_mem_desc *tgt, splay_tree_key n,$/;" f file: +gomp_map_lookup target.c /^gomp_map_lookup (splay_tree mem_map, splay_tree_key key)$/;" f file: +gomp_map_pointer target.c /^gomp_map_pointer (struct target_mem_desc *tgt, uintptr_t host_ptr,$/;" f file: +gomp_map_val target.c /^gomp_map_val (struct target_mem_desc *tgt, void **hostaddrs, size_t i)$/;" f file: +gomp_map_vars target.c /^gomp_map_vars (struct gomp_device_descr *devicep, size_t mapnum,$/;" f +gomp_map_vars_existing target.c /^gomp_map_vars_existing (struct gomp_device_descr *devicep, splay_tree_key oldn,$/;" f file: +gomp_map_vars_kind libgomp.h /^enum gomp_map_vars_kind$/;" g +gomp_max_active_levels_var env.c /^unsigned long gomp_max_active_levels_var = INT_MAX;$/;" v +gomp_max_task_priority_var env.c /^int gomp_max_task_priority_var = 0;$/;" v +gomp_mutex_destroy config/linux/mutex.h /^gomp_mutex_destroy (gomp_mutex_t *mutex)$/;" f +gomp_mutex_destroy config/nvptx/mutex.h /^gomp_mutex_destroy (gomp_mutex_t *mutex)$/;" f +gomp_mutex_destroy config/posix/mutex.h /^static inline void gomp_mutex_destroy (gomp_mutex_t *mutex)$/;" f +gomp_mutex_destroy config/rtems/mutex.h /^static inline void gomp_mutex_destroy (gomp_mutex_t *mutex)$/;" f +gomp_mutex_init config/linux/mutex.h /^gomp_mutex_init (gomp_mutex_t *mutex)$/;" f +gomp_mutex_init config/nvptx/mutex.h /^gomp_mutex_init (gomp_mutex_t *mutex)$/;" f +gomp_mutex_init config/posix/mutex.h /^static inline void gomp_mutex_init (gomp_mutex_t *mutex)$/;" f +gomp_mutex_init config/rtems/mutex.h /^static inline void gomp_mutex_init (gomp_mutex_t *mutex)$/;" f +gomp_mutex_lock config/linux/mutex.h /^gomp_mutex_lock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_lock config/nvptx/mutex.h /^gomp_mutex_lock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_lock config/posix/mutex.h /^static inline void gomp_mutex_lock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_lock config/rtems/mutex.h /^static inline void gomp_mutex_lock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_lock_slow config/linux/mutex.c /^gomp_mutex_lock_slow (gomp_mutex_t *mutex, int oldval)$/;" f +gomp_mutex_t config/linux/mutex.h /^typedef int gomp_mutex_t;$/;" t +gomp_mutex_t config/nvptx/mutex.h /^typedef int gomp_mutex_t;$/;" t +gomp_mutex_t config/posix/mutex.h /^typedef pthread_mutex_t gomp_mutex_t;$/;" t +gomp_mutex_t config/rtems/mutex.h /^typedef struct _Mutex_Control gomp_mutex_t;$/;" t typeref:struct:_Mutex_Control +gomp_mutex_unlock config/linux/mutex.h /^gomp_mutex_unlock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_unlock config/nvptx/mutex.h /^gomp_mutex_unlock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_unlock config/posix/mutex.h /^static inline void gomp_mutex_unlock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_unlock config/rtems/mutex.h /^static inline void gomp_mutex_unlock (gomp_mutex_t *mutex)$/;" f +gomp_mutex_unlock_slow config/linux/mutex.c /^gomp_mutex_unlock_slow (gomp_mutex_t *mutex)$/;" f +gomp_new_icv team.c /^gomp_new_icv (void)$/;" f +gomp_new_team team.c /^gomp_new_team (unsigned nthreads)$/;" f +gomp_nthreads_var_list env.c /^unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;$/;" v +gomp_nthreads_var_list_len env.c /^unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;$/;" v +gomp_num_teams_var env.c /^unsigned int gomp_num_teams_var;$/;" v +gomp_nvptx_main config/nvptx/team.c /^gomp_nvptx_main (void (*fn) (void *), void *fn_data)$/;" f +gomp_ordered_first ordered.c /^gomp_ordered_first (void)$/;" f +gomp_ordered_last ordered.c /^gomp_ordered_last (void)$/;" f +gomp_ordered_next ordered.c /^gomp_ordered_next (void)$/;" f +gomp_ordered_static_init ordered.c /^gomp_ordered_static_init (void)$/;" f +gomp_ordered_static_next ordered.c /^gomp_ordered_static_next (void)$/;" f +gomp_ordered_sync ordered.c /^gomp_ordered_sync (void)$/;" f +gomp_parallel_loop_start loop.c /^gomp_parallel_loop_start (void (*fn) (void *), void *data,$/;" f file: +gomp_places_list env.c /^void **gomp_places_list;$/;" v +gomp_places_list_len env.c /^unsigned long gomp_places_list_len;$/;" v +gomp_ptrlock_destroy config/linux/ptrlock.h /^static inline void gomp_ptrlock_destroy (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_destroy config/nvptx/ptrlock.h /^static inline void gomp_ptrlock_destroy (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_destroy config/posix/ptrlock.h /^static inline void gomp_ptrlock_destroy (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_get config/linux/ptrlock.h /^static inline void *gomp_ptrlock_get (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_get config/nvptx/ptrlock.h /^static inline void *gomp_ptrlock_get (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_get config/posix/ptrlock.h /^static inline void *gomp_ptrlock_get (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_get_slow config/linux/ptrlock.c /^gomp_ptrlock_get_slow (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_init config/linux/ptrlock.h /^static inline void gomp_ptrlock_init (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_init config/nvptx/ptrlock.h /^static inline void gomp_ptrlock_init (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_init config/posix/ptrlock.h /^static inline void gomp_ptrlock_init (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_set config/linux/ptrlock.h /^static inline void gomp_ptrlock_set (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_set config/nvptx/ptrlock.h /^static inline void gomp_ptrlock_set (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_set config/posix/ptrlock.h /^static inline void gomp_ptrlock_set (gomp_ptrlock_t *ptrlock, void *ptr)$/;" f +gomp_ptrlock_set_slow config/linux/ptrlock.c /^gomp_ptrlock_set_slow (gomp_ptrlock_t *ptrlock)$/;" f +gomp_ptrlock_t config/linux/ptrlock.h /^typedef void *gomp_ptrlock_t;$/;" t +gomp_ptrlock_t config/nvptx/ptrlock.h /^typedef void *gomp_ptrlock_t;$/;" t +gomp_ptrlock_t config/posix/ptrlock.h /^typedef struct { void *ptr; gomp_mutex_t lock; } gomp_ptrlock_t;$/;" t typeref:struct:__anon34 +gomp_realloc alloc.c /^gomp_realloc (void *old, size_t size)$/;" f +gomp_realloc_unlock target.c /^gomp_realloc_unlock (void *old, size_t size)$/;" f file: +gomp_release_thread_pool config/nvptx/pool.h /^gomp_release_thread_pool (struct gomp_thread_pool *pool)$/;" f +gomp_release_thread_pool config/posix/pool.h /^gomp_release_thread_pool (struct gomp_thread_pool *pool)$/;" f +gomp_release_thread_pool config/rtems/pool.h /^gomp_release_thread_pool (struct gomp_thread_pool *pool)$/;" f +gomp_resolve_num_threads parallel.c /^gomp_resolve_num_threads (unsigned specified, unsigned count)$/;" f +gomp_schedule_type libgomp.h /^enum gomp_schedule_type$/;" g +gomp_sections_init sections.c /^gomp_sections_init (struct gomp_work_share *ws, unsigned count)$/;" f file: +gomp_sem config/posix/sem.h /^struct gomp_sem$/;" s +gomp_sem_destroy config/linux/sem.h /^gomp_sem_destroy (gomp_sem_t *sem)$/;" f +gomp_sem_destroy config/nvptx/sem.h /^gomp_sem_destroy (gomp_sem_t *sem)$/;" f +gomp_sem_destroy config/posix/sem.c /^void gomp_sem_destroy (gomp_sem_t *sem)$/;" f +gomp_sem_destroy config/posix/sem.h /^static inline void gomp_sem_destroy (gomp_sem_t *sem)$/;" f +gomp_sem_destroy config/rtems/sem.h /^static inline void gomp_sem_destroy (gomp_sem_t *sem)$/;" f +gomp_sem_init config/linux/sem.h /^gomp_sem_init (gomp_sem_t *sem, int value)$/;" f +gomp_sem_init config/nvptx/sem.h /^gomp_sem_init (gomp_sem_t *sem, int value)$/;" f +gomp_sem_init config/posix/sem.c /^void gomp_sem_init (gomp_sem_t *sem, int value)$/;" f +gomp_sem_init config/posix/sem.h /^static inline void gomp_sem_init (gomp_sem_t *sem, int value)$/;" f +gomp_sem_init config/rtems/sem.h /^static inline void gomp_sem_init (gomp_sem_t *sem, int value)$/;" f +gomp_sem_post config/linux/sem.h /^gomp_sem_post (gomp_sem_t *sem)$/;" f +gomp_sem_post config/nvptx/sem.h /^gomp_sem_post (gomp_sem_t *sem)$/;" f +gomp_sem_post config/posix/sem.c /^void gomp_sem_post (gomp_sem_t *sem)$/;" f +gomp_sem_post config/posix/sem.h /^static inline void gomp_sem_post (gomp_sem_t *sem)$/;" f +gomp_sem_post config/rtems/sem.h /^static inline void gomp_sem_post (gomp_sem_t *sem)$/;" f +gomp_sem_post_slow config/linux/sem.c /^gomp_sem_post_slow (gomp_sem_t *sem)$/;" f +gomp_sem_t config/linux/sem.h /^typedef int gomp_sem_t;$/;" t +gomp_sem_t config/nvptx/sem.h /^typedef int gomp_sem_t;$/;" t +gomp_sem_t config/posix/sem.h /^typedef sem_t gomp_sem_t;$/;" t +gomp_sem_t config/posix/sem.h /^typedef struct gomp_sem gomp_sem_t;$/;" t typeref:struct:gomp_sem +gomp_sem_t config/rtems/sem.h /^typedef struct _Semaphore_Control gomp_sem_t;$/;" t typeref:struct:_Semaphore_Control +gomp_sem_wait config/linux/sem.h /^gomp_sem_wait (gomp_sem_t *sem)$/;" f +gomp_sem_wait config/nvptx/sem.h /^gomp_sem_wait (gomp_sem_t *sem)$/;" f +gomp_sem_wait config/posix/sem.c /^gomp_sem_wait (gomp_sem_t *sem)$/;" f +gomp_sem_wait config/posix/sem.c /^void gomp_sem_wait (gomp_sem_t *sem)$/;" f +gomp_sem_wait config/rtems/sem.h /^static inline void gomp_sem_wait (gomp_sem_t *sem)$/;" f +gomp_sem_wait_slow config/linux/sem.c /^gomp_sem_wait_slow (gomp_sem_t *sem, int count)$/;" f +gomp_set_lock_25 config/posix/lock.c /^gomp_set_lock_25 (omp_lock_25_t *lock)$/;" f +gomp_set_lock_30 config/posix/lock.c /^gomp_set_lock_30 (omp_lock_t *lock)$/;" f +gomp_set_lock_30 libgomp.h 1111;" d +gomp_set_lock_30 lock.c /^gomp_set_lock_30 (omp_lock_t *lock)$/;" f +gomp_set_lock__25 fortran.c /^gomp_set_lock__25 (omp_lock_25_arg_t lock)$/;" f +gomp_set_lock__30 fortran.c /^gomp_set_lock__30 (omp_lock_arg_t lock)$/;" f +gomp_set_lock__30 fortran.c 90;" d file: +gomp_set_nest_lock_25 config/linux/lock.c /^gomp_set_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_set_nest_lock_25 config/posix/lock.c /^gomp_set_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_set_nest_lock_30 config/posix/lock.c /^gomp_set_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_set_nest_lock_30 libgomp.h 1116;" d +gomp_set_nest_lock_30 lock.c /^gomp_set_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_set_nest_lock__25 fortran.c /^gomp_set_nest_lock__25 (omp_nest_lock_25_arg_t lock)$/;" f +gomp_set_nest_lock__30 fortran.c /^gomp_set_nest_lock__30 (omp_nest_lock_arg_t lock)$/;" f +gomp_set_nest_lock__30 fortran.c 95;" d file: +gomp_simple_barrier_destroy config/nvptx/simple-bar.h /^gomp_simple_barrier_destroy (gomp_simple_barrier_t *bar)$/;" f +gomp_simple_barrier_destroy config/posix/simple-bar.h /^gomp_simple_barrier_destroy (gomp_simple_barrier_t *bar)$/;" f +gomp_simple_barrier_init config/nvptx/simple-bar.h /^gomp_simple_barrier_init (gomp_simple_barrier_t *bar, unsigned count)$/;" f +gomp_simple_barrier_init config/posix/simple-bar.h /^gomp_simple_barrier_init (gomp_simple_barrier_t *bar, unsigned count)$/;" f +gomp_simple_barrier_reinit config/posix/simple-bar.h /^gomp_simple_barrier_reinit (gomp_simple_barrier_t *bar, unsigned count)$/;" f +gomp_simple_barrier_t config/nvptx/simple-bar.h /^} gomp_simple_barrier_t;$/;" t typeref:struct:__anon38 +gomp_simple_barrier_t config/posix/simple-bar.h /^} gomp_simple_barrier_t;$/;" t typeref:struct:__anon33 +gomp_simple_barrier_wait config/nvptx/simple-bar.h /^gomp_simple_barrier_wait (gomp_simple_barrier_t *bar)$/;" f +gomp_simple_barrier_wait config/posix/simple-bar.h /^gomp_simple_barrier_wait (gomp_simple_barrier_t *bar)$/;" f +gomp_simple_barrier_wait_last config/nvptx/simple-bar.h /^gomp_simple_barrier_wait_last (gomp_simple_barrier_t *bar)$/;" f +gomp_simple_barrier_wait_last config/posix/simple-bar.h /^gomp_simple_barrier_wait_last (gomp_simple_barrier_t *bar)$/;" f +gomp_spin_count_var env.c /^unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;$/;" v +gomp_target_data_fallback target.c /^gomp_target_data_fallback (void)$/;" f file: +gomp_target_fallback target.c /^gomp_target_fallback (void (*fn) (void *), void **hostaddrs)$/;" f file: +gomp_target_fini target.c /^gomp_target_fini (void)$/;" f file: +gomp_target_init target.c /^gomp_target_init (void)$/;" f file: +gomp_target_task libgomp.h /^struct gomp_target_task$/;" s +gomp_target_task_completion task.c /^gomp_target_task_completion (struct gomp_team *team, struct gomp_task *task)$/;" f file: +gomp_target_task_fn config/nvptx/task.c /^gomp_target_task_fn (void *data)$/;" f +gomp_target_task_fn target.c /^gomp_target_task_fn (void *data)$/;" f +gomp_target_task_state libgomp.h /^enum gomp_target_task_state$/;" g +gomp_task libgomp.h /^struct gomp_task$/;" s +gomp_task_depend_entry libgomp.h /^struct gomp_task_depend_entry$/;" s +gomp_task_handle_depend task.c /^gomp_task_handle_depend (struct gomp_task *task, struct gomp_task *parent,$/;" f file: +gomp_task_handle_tdg_depend tdg.c /^void gomp_task_handle_tdg_depend (struct gomp_task *task, struct gomp_task *parent,$/;" f +gomp_task_icv libgomp.h /^struct gomp_task_icv$/;" s +gomp_task_kind libgomp.h /^enum gomp_task_kind$/;" g +gomp_task_maybe_wait_for_dependencies task.c /^gomp_task_maybe_wait_for_dependencies (void **depend)$/;" f +gomp_task_run_post_handle_depend task.c /^gomp_task_run_post_handle_depend (struct gomp_task *child_task,$/;" f file: +gomp_task_run_post_handle_depend_hash task.c /^gomp_task_run_post_handle_depend_hash (struct gomp_task *child_task)$/;" f file: +gomp_task_run_post_handle_dependers task.c /^gomp_task_run_post_handle_dependers (struct gomp_task *child_task,$/;" f file: +gomp_task_run_post_remove_parent task.c /^gomp_task_run_post_remove_parent (struct gomp_task *child_task)$/;" f file: +gomp_task_run_post_remove_taskgroup task.c /^gomp_task_run_post_remove_taskgroup (struct gomp_task *child_task)$/;" f file: +gomp_task_run_pre task.c /^gomp_task_run_pre (struct gomp_task *child_task, struct gomp_task *parent,$/;" f file: +gomp_taskgroup libgomp.h /^struct gomp_taskgroup$/;" s +gomp_taskwait libgomp.h /^struct gomp_taskwait$/;" s +gomp_tdg_get_unresolved_dependencies tdg.c /^gomp_tdg_get_unresolved_dependencies (struct gomp_tdg_node *tdg)$/;" f +gomp_tdg_node tdg.h /^struct gomp_tdg_node {$/;" s +gomp_tdg_num_input_depend tdg.c /^char gomp_tdg_num_input_depend(struct gomp_tdg_node *tdg)$/;" f +gomp_tdg_t env.c /^enum gomp_tdg_type gomp_tdg_t;$/;" v typeref:enum:gomp_tdg_type +gomp_tdg_task libgomp.h /^struct gomp_tdg_task$/;" s +gomp_tdg_task_run_post_remove_parent task.c /^gomp_tdg_task_run_post_remove_parent (struct gomp_tdg_task *child_tdg_task)$/;" f file: +gomp_tdg_task_run_pre task.c /^gomp_tdg_task_run_pre (struct gomp_tdg_task *child_task, struct gomp_team *team)$/;" f file: +gomp_tdg_type tdg.h /^enum gomp_tdg_type$/;" g +gomp_team libgomp.h /^struct gomp_team$/;" s +gomp_team_barrier_cancel config/linux/bar.c /^gomp_team_barrier_cancel (struct gomp_team *team)$/;" f +gomp_team_barrier_cancel config/nvptx/bar.c /^gomp_team_barrier_cancel (struct gomp_team *team)$/;" f +gomp_team_barrier_cancel config/posix/bar.c /^gomp_team_barrier_cancel (struct gomp_team *team)$/;" f +gomp_team_barrier_cancel config/rtems/bar.c /^gomp_team_barrier_cancel (struct gomp_team *team)$/;" f +gomp_team_barrier_cancelled config/linux/bar.h /^gomp_team_barrier_cancelled (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_cancelled config/nvptx/bar.h /^gomp_team_barrier_cancelled (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_cancelled config/posix/bar.h /^gomp_team_barrier_cancelled (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_cancelled config/rtems/bar.h /^gomp_team_barrier_cancelled (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_clear_task_pending config/linux/bar.h /^gomp_team_barrier_clear_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_clear_task_pending config/nvptx/bar.h /^gomp_team_barrier_clear_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_clear_task_pending config/posix/bar.h /^gomp_team_barrier_clear_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_clear_task_pending config/rtems/bar.h /^gomp_team_barrier_clear_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_done config/linux/bar.h /^gomp_team_barrier_done (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_done config/nvptx/bar.h /^gomp_team_barrier_done (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_done config/posix/bar.h /^gomp_team_barrier_done (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_done config/rtems/bar.h /^gomp_team_barrier_done (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_set_task_pending config/linux/bar.h /^gomp_team_barrier_set_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_task_pending config/nvptx/bar.h /^gomp_team_barrier_set_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_task_pending config/posix/bar.h /^gomp_team_barrier_set_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_task_pending config/rtems/bar.h /^gomp_team_barrier_set_task_pending (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_waiting_for_tasks config/linux/bar.h /^gomp_team_barrier_set_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_waiting_for_tasks config/nvptx/bar.h /^gomp_team_barrier_set_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_waiting_for_tasks config/posix/bar.h /^gomp_team_barrier_set_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_set_waiting_for_tasks config/rtems/bar.h /^gomp_team_barrier_set_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait config/linux/bar.c /^gomp_team_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait config/nvptx/bar.c /^gomp_team_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait config/posix/bar.c /^gomp_team_barrier_wait (gomp_barrier_t *barrier)$/;" f +gomp_team_barrier_wait config/rtems/bar.c /^gomp_team_barrier_wait (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_cancel config/linux/bar.c /^gomp_team_barrier_wait_cancel (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_cancel config/nvptx/bar.c /^gomp_team_barrier_wait_cancel (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_cancel config/posix/bar.c /^gomp_team_barrier_wait_cancel (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_cancel config/rtems/bar.c /^gomp_team_barrier_wait_cancel (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_cancel_end config/linux/bar.c /^gomp_team_barrier_wait_cancel_end (gomp_barrier_t *bar,$/;" f +gomp_team_barrier_wait_cancel_end config/nvptx/bar.c /^gomp_team_barrier_wait_cancel_end (gomp_barrier_t *bar,$/;" f +gomp_team_barrier_wait_cancel_end config/posix/bar.c /^gomp_team_barrier_wait_cancel_end (gomp_barrier_t *bar,$/;" f +gomp_team_barrier_wait_cancel_end config/rtems/bar.c /^gomp_team_barrier_wait_cancel_end (gomp_barrier_t *bar,$/;" f +gomp_team_barrier_wait_end config/linux/bar.c /^gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_wait_end config/nvptx/bar.c /^gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_wait_end config/posix/bar.c /^gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_wait_end config/rtems/bar.c /^gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state)$/;" f +gomp_team_barrier_wait_final config/linux/bar.c /^gomp_team_barrier_wait_final (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_final config/nvptx/bar.c /^gomp_team_barrier_wait_final (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_final config/posix/bar.h /^gomp_team_barrier_wait_final (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wait_final config/rtems/bar.c /^gomp_team_barrier_wait_final (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_waiting_for_tasks config/linux/bar.h /^gomp_team_barrier_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_waiting_for_tasks config/nvptx/bar.h /^gomp_team_barrier_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_waiting_for_tasks config/posix/bar.h /^gomp_team_barrier_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_waiting_for_tasks config/rtems/bar.h /^gomp_team_barrier_waiting_for_tasks (gomp_barrier_t *bar)$/;" f +gomp_team_barrier_wake config/linux/bar.c /^gomp_team_barrier_wake (gomp_barrier_t *bar, int count)$/;" f +gomp_team_barrier_wake config/nvptx/bar.c /^gomp_team_barrier_wake (gomp_barrier_t *bar, int count)$/;" f +gomp_team_barrier_wake config/posix/bar.c /^gomp_team_barrier_wake (gomp_barrier_t *bar, int count)$/;" f +gomp_team_barrier_wake config/rtems/bar.c /^gomp_team_barrier_wake (gomp_barrier_t *bar, int count)$/;" f +gomp_team_end team.c /^gomp_team_end (void)$/;" f +gomp_team_start config/nvptx/team.c /^gomp_team_start (void (*fn) (void *), void *data, unsigned nthreads,$/;" f +gomp_team_start team.c /^gomp_team_start (void (*fn) (void *), void *data, unsigned nthreads,$/;" f +gomp_team_state libgomp.h /^struct gomp_team_state$/;" s +gomp_test_lock_25 config/posix/lock.c /^gomp_test_lock_25 (omp_lock_25_t *lock)$/;" f +gomp_test_lock_30 config/posix/lock.c /^gomp_test_lock_30 (omp_lock_t *lock)$/;" f +gomp_test_lock_30 libgomp.h 1113;" d +gomp_test_lock_30 lock.c /^gomp_test_lock_30 (omp_lock_t *lock)$/;" f +gomp_test_lock__25 fortran.c /^gomp_test_lock__25 (omp_lock_25_arg_t lock)$/;" f +gomp_test_lock__30 fortran.c /^gomp_test_lock__30 (omp_lock_arg_t lock)$/;" f +gomp_test_lock__30 fortran.c 92;" d file: +gomp_test_nest_lock_25 config/linux/lock.c /^gomp_test_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_test_nest_lock_25 config/posix/lock.c /^gomp_test_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_test_nest_lock_30 config/posix/lock.c /^gomp_test_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_test_nest_lock_30 libgomp.h 1118;" d +gomp_test_nest_lock_30 lock.c /^gomp_test_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_test_nest_lock__25 fortran.c /^gomp_test_nest_lock__25 (omp_nest_lock_25_arg_t lock)$/;" f +gomp_test_nest_lock__30 fortran.c /^gomp_test_nest_lock__30 (omp_nest_lock_arg_t lock)$/;" f +gomp_test_nest_lock__30 fortran.c 97;" d file: +gomp_thread libgomp.h /^static inline struct gomp_thread *gomp_thread (void)$/;" f +gomp_thread libgomp.h /^struct gomp_thread$/;" s +gomp_thread_attr team.c /^pthread_attr_t gomp_thread_attr;$/;" v +gomp_thread_destructor team.c /^pthread_key_t gomp_thread_destructor;$/;" v +gomp_thread_pool libgomp.h /^struct gomp_thread_pool$/;" s +gomp_thread_pool_reservoir config/rtems/pool.h /^struct gomp_thread_pool_reservoir {$/;" s +gomp_thread_pool_reservoirs config/rtems/proc.c /^struct gomp_thread_pool_reservoir **gomp_thread_pool_reservoirs;$/;" v typeref:struct:gomp_thread_pool_reservoir +gomp_thread_start config/nvptx/team.c /^gomp_thread_start (struct gomp_thread_pool *pool)$/;" f file: +gomp_thread_start team.c /^gomp_thread_start (void *xdata)$/;" f file: +gomp_thread_start_data team.c /^struct gomp_thread_start_data$/;" s file: +gomp_throttled_spin_count_var env.c /^unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;$/;" v +gomp_tid config/linux/lock.c /^static inline int gomp_tid (void)$/;" f file: +gomp_tls_data team.c /^__thread struct gomp_thread gomp_tls_data;$/;" v typeref:struct:gomp_thread +gomp_tls_key team.c /^pthread_key_t gomp_tls_key;$/;" v +gomp_tls_rtems_data config/rtems/pool.h /^struct gomp_tls_rtems_data {$/;" s +gomp_tls_rtems_data config/rtems/proc.c /^__thread struct gomp_tls_rtems_data gomp_tls_rtems_data;$/;" v typeref:struct:gomp_tls_rtems_data +gomp_ull iter_ull.c /^typedef unsigned long long gomp_ull;$/;" t file: +gomp_ull loop_ull.c /^typedef unsigned long long gomp_ull;$/;" t file: +gomp_ull ordered.c /^typedef unsigned long long gomp_ull;$/;" t file: +gomp_unload_device target.c /^gomp_unload_device (struct gomp_device_descr *devicep)$/;" f +gomp_unload_image_from_device target.c /^gomp_unload_image_from_device (struct gomp_device_descr *devicep,$/;" f file: +gomp_unmap_tgt target.c /^gomp_unmap_tgt (struct target_mem_desc *tgt)$/;" f file: +gomp_unmap_vars target.c /^gomp_unmap_vars (struct target_mem_desc *tgt, bool do_copyfrom)$/;" f +gomp_unset_lock_25 config/posix/lock.c /^gomp_unset_lock_25 (omp_lock_25_t *lock)$/;" f +gomp_unset_lock_30 config/posix/lock.c /^gomp_unset_lock_30 (omp_lock_t *lock)$/;" f +gomp_unset_lock_30 libgomp.h 1112;" d +gomp_unset_lock_30 lock.c /^gomp_unset_lock_30 (omp_lock_t *lock)$/;" f +gomp_unset_lock__25 fortran.c /^gomp_unset_lock__25 (omp_lock_25_arg_t lock)$/;" f +gomp_unset_lock__30 fortran.c /^gomp_unset_lock__30 (omp_lock_arg_t lock)$/;" f +gomp_unset_lock__30 fortran.c 91;" d file: +gomp_unset_nest_lock_25 config/linux/lock.c /^gomp_unset_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_unset_nest_lock_25 config/posix/lock.c /^gomp_unset_nest_lock_25 (omp_nest_lock_25_t *lock)$/;" f +gomp_unset_nest_lock_30 config/posix/lock.c /^gomp_unset_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_unset_nest_lock_30 libgomp.h 1117;" d +gomp_unset_nest_lock_30 lock.c /^gomp_unset_nest_lock_30 (omp_nest_lock_t *lock)$/;" f +gomp_unset_nest_lock__25 fortran.c /^gomp_unset_nest_lock__25 (omp_nest_lock_25_arg_t lock)$/;" f +gomp_unset_nest_lock__30 fortran.c /^gomp_unset_nest_lock__30 (omp_nest_lock_arg_t lock)$/;" f +gomp_unset_nest_lock__30 fortran.c 96;" d file: +gomp_update target.c /^gomp_update (struct gomp_device_descr *devicep, size_t mapnum, void **hostaddrs,$/;" f file: +gomp_update_tdg tdg.c /^void gomp_update_tdg(struct gomp_tdg_task *task, struct gomp_tdg_node *tdg)$/;" f +gomp_update_tdg_dependency tdg.c /^int gomp_update_tdg_dependency(struct gomp_tdg_task *task)$/;" f +gomp_vdebug error.c /^gomp_vdebug (int kind __attribute__ ((unused)), const char *msg, va_list list)$/;" f +gomp_vdebug error.c 39;" d file: +gomp_vdebug libgomp.h 103;" d +gomp_verror error.c /^gomp_verror (const char *fmt, va_list list)$/;" f +gomp_vfatal error.c /^gomp_vfatal (const char *fmt, va_list list)$/;" f +gomp_work_share libgomp.h /^struct gomp_work_share$/;" s +gomp_work_share_end work.c /^gomp_work_share_end (void)$/;" f +gomp_work_share_end_cancel work.c /^gomp_work_share_end_cancel (void)$/;" f +gomp_work_share_end_nowait work.c /^gomp_work_share_end_nowait (void)$/;" f +gomp_work_share_init_done libgomp.h /^gomp_work_share_init_done (void)$/;" f +gomp_work_share_start work.c /^gomp_work_share_start (bool ordered)$/;" f +goo testsuite/libgomp.c/examples-4/simd-6.c /^float goo(float *p){$/;" f +goo testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function goo(/;" f module:SIMD6_mod +gr testsuite/libgomp.c++/target-2-aux.cc /^double *&gr = g;$/;" v +grainsize testsuite/libgomp.c/taskloop-4.c /^grainsize (int a, int b, int c, int d)$/;" f +grainsize testsuite/libgomp.fortran/taskloop4.f90 /^ subroutine grainsize /;" s +gramSchmidt testsuite/libgomp.c/examples-4/target_data-3.c /^void gramSchmidt (int Q[][COLS], const int rows, const int cols)$/;" f +gramSchmidt testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ subroutine gramSchmidt /;" s module:e_51_3_mod +gramSchmidt_ref testsuite/libgomp.c/examples-4/target_data-3.c /^void gramSchmidt_ref (int Q[][COLS], const int rows, const int cols)$/;" f +gramSchmidt_ref testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ subroutine gramSchmidt_ref /;" s module:e_51_3_mod +gridified_kernel_p plugin/plugin-hsa.c /^ bool gridified_kernel_p;$/;" m struct:hsa_kernel_description file: +gridified_kernel_p plugin/plugin-hsa.c /^ bool gridified_kernel_p;$/;" m struct:kernel_info file: +group_segment_size plugin/plugin-hsa.c /^ uint32_t group_segment_size;$/;" m struct:GOMP_hsa_kernel_dispatch file: +group_segment_size plugin/plugin-hsa.c /^ uint32_t group_segment_size;$/;" m struct:kernel_info file: +gs testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsum, gs,/;" v program:reduction +gs1 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1,/;" v program:reduction +gs2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2,/;" v program:reduction +gv_np_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gv_np_1()$/;" f +gw_np_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gw_np_1()$/;" f +gwv_np_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gwv_np_1()$/;" f +gwv_np_2 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gwv_np_2()$/;" f +gwv_np_3 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gwv_np_3()$/;" f +gwv_np_4 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void gwv_np_4()$/;" f +h plugin/plugin-nvptx.c /^ void *h;$/;" m struct:ptx_stream file: +h testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +h testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +h testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +h testsuite/libgomp.c/pr26943-2.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +h testsuite/libgomp.c/pr26943-3.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +h testsuite/libgomp.c/pr26943-4.c /^char e[10] = "a", f[10] = "b", g[10] = "c", h[10] = "d";$/;" v +h testsuite/libgomp.c/target-31.c /^int e[2] = { 5, 6 }, f[2] = { 7, 8 }, g[2] = { 9, 10 }, h[2] = { 11, 12 };$/;" v +h testsuite/libgomp.fortran/alloc-comp-1.f90 /^ type (dl), allocatable :: h(/;" k type:dt +h testsuite/libgomp.fortran/alloc-comp-2.f90 /^ type (dl), allocatable :: h(/;" k type:dt +h testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type (dl), allocatable :: h(/;" k type:dt +h testsuite/libgomp.fortran/character1.f90 /^ cha/;" v +h testsuite/libgomp.fortran/character2.f90 /^ cha/;" v +h testsuite/libgomp.fortran/udr14.f90 /^ integer, allocatable :: h(/;" k type:dt +h1 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1,/;" v program:reduction +h2 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1, h2,/;" v program:reduction +h_begin plugin/plugin-nvptx.c /^ void *h_begin;$/;" m struct:ptx_stream file: +h_end plugin/plugin-nvptx.c /^ void *h_end;$/;" m struct:ptx_stream file: +h_next plugin/plugin-nvptx.c /^ void *h_next;$/;" m struct:ptx_stream file: +h_prev plugin/plugin-nvptx.c /^ void *h_prev;$/;" m struct:ptx_stream file: +h_tail plugin/plugin-nvptx.c /^ void *h_tail;$/;" m struct:ptx_stream file: +handle plugin/hsa_ext_finalize.h /^ uint64_t handle;$/;" m struct:hsa_ext_image_s +handle plugin/hsa_ext_finalize.h /^ uint64_t handle;$/;" m struct:hsa_ext_program_s +handle plugin/hsa_ext_finalize.h /^ uint64_t handle;$/;" m struct:hsa_ext_sampler_s +handle_omp_display_env env.c /^handle_omp_display_env (unsigned long stacksize, int wait_policy)$/;" f file: +hash_entry_type task.c /^typedef struct gomp_task_depend_entry *hash_entry_type;$/;" t typeref:struct:gomp_task_depend_entry file: +hash_entry_type tdg.c /^typedef struct gomp_task_depend_entry *hash_entry_type;$/;" t typeref:struct:gomp_task_depend_entry file: +hash_pointer hashtab.h /^hash_pointer (const void *p)$/;" f +hashval_t hashtab.h /^typedef unsigned int hashval_t;$/;" t +height plugin/hsa_ext_finalize.h /^ size_t height;$/;" m struct:hsa_ext_image_descriptor_s +height testsuite/libgomp.hsa.c/tiling-1.c /^ int height;$/;" m struct:__anon23 file: +height testsuite/libgomp.hsa.c/tiling-2.c /^ int height;$/;" m struct:__anon22 file: +hi testsuite/libgomp.c/sort-1.c /^ int hi;$/;" m struct:int_pair file: +high testsuite/libgomp.hsa.c/switch-branch-1.c 72;" d file: +high testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ integer, parameter :: n = 20, c = 10, low = 5, high /;" v program:subarrays +higher_prime_index hashtab.h /^higher_prime_index (unsigned long n)$/;" f +hold testsuite/libgomp.c++/pr26943.C /^static volatile int hold;$/;" v file: +host2dev_func libgomp.h /^ __typeof (GOMP_OFFLOAD_host2dev) *host2dev_func;$/;" m struct:gomp_device_descr +host_alloc oacc-host.c /^host_alloc (int n __attribute__ ((unused)), size_t s)$/;" f file: +host_dev2host oacc-host.c /^host_dev2host (int n __attribute__ ((unused)),$/;" f file: +host_dispatch oacc-host.c /^static struct gomp_device_descr host_dispatch =$/;" v typeref:struct:gomp_device_descr file: +host_dispatch oacc-host.c /^static struct gomp_device_descr host_dispatch;$/;" v typeref:struct:gomp_device_descr file: +host_end libgomp.h /^ uintptr_t host_end;$/;" m struct:splay_tree_key_s +host_fini_device oacc-host.c /^host_fini_device (int n __attribute__ ((unused)))$/;" f file: +host_free oacc-host.c /^host_free (int n __attribute__ ((unused)), void *p)$/;" f file: +host_get_caps oacc-host.c /^host_get_caps (void)$/;" f file: +host_get_name oacc-host.c /^host_get_name (void)$/;" f file: +host_get_num_devices oacc-host.c /^host_get_num_devices (void)$/;" f file: +host_get_type oacc-host.c /^host_get_type (void)$/;" f file: +host_host2dev oacc-host.c /^host_host2dev (int n __attribute__ ((unused)),$/;" f file: +host_init_device oacc-host.c /^host_init_device (int n __attribute__ ((unused)))$/;" f file: +host_load_image oacc-host.c /^host_load_image (int n __attribute__ ((unused)),$/;" f file: +host_openacc_async_set_async oacc-host.c /^host_openacc_async_set_async (int async __attribute__ ((unused)))$/;" f file: +host_openacc_async_test oacc-host.c /^host_openacc_async_test (int async __attribute__ ((unused)))$/;" f file: +host_openacc_async_test_all oacc-host.c /^host_openacc_async_test_all (void)$/;" f file: +host_openacc_async_wait oacc-host.c /^host_openacc_async_wait (int async __attribute__ ((unused)))$/;" f file: +host_openacc_async_wait_all oacc-host.c /^host_openacc_async_wait_all (void)$/;" f file: +host_openacc_async_wait_all_async oacc-host.c /^host_openacc_async_wait_all_async (int async __attribute__ ((unused)))$/;" f file: +host_openacc_async_wait_async oacc-host.c /^host_openacc_async_wait_async (int async1 __attribute__ ((unused)),$/;" f file: +host_openacc_create_thread_data oacc-host.c /^host_openacc_create_thread_data (int ord __attribute__ ((unused)))$/;" f file: +host_openacc_destroy_thread_data oacc-host.c /^host_openacc_destroy_thread_data (void *tls_data __attribute__ ((unused)))$/;" f file: +host_openacc_exec oacc-host.c /^host_openacc_exec (void (*fn) (void *),$/;" f file: +host_openacc_register_async_cleanup oacc-host.c /^host_openacc_register_async_cleanup (void *targ_mem_desc __attribute__ ((unused)),$/;" f file: +host_run oacc-host.c /^host_run (int n __attribute__ ((unused)), void *fn_ptr, void *vars,$/;" f file: +host_start libgomp.h /^ uintptr_t host_start;$/;" m struct:splay_tree_key_s +host_table target.c /^ const void *host_table;$/;" m struct:offload_image_descr file: +host_thread plugin/plugin-nvptx.c /^ pthread_t host_thread;$/;" m struct:ptx_stream file: +host_unload_image oacc-host.c /^host_unload_image (int n __attribute__ ((unused)),$/;" f file: +host_version oacc-host.c /^host_version (void)$/;" f file: +hostaddrs libgomp.h /^ void *hostaddrs[];$/;" m struct:gomp_target_task +hpad testsuite/libgomp.hsa.c/tiling-1.c /^ int hpad;$/;" m struct:__anon23 file: +hpad testsuite/libgomp.hsa.c/tiling-2.c /^ int hpad;$/;" m struct:__anon22 file: +hs1 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1, vs2, cs1, cs2, hs1,/;" v program:reduction +hs2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1, vs2, cs1, cs2, hs1, hs2$/;" v program:reduction +hsa_agent_get_info_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_agent_get_info_fn) (hsa_agent_t agent,$/;" m struct:hsa_runtime_fn_info file: +hsa_agent_iterate_regions_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_agent_iterate_regions_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_context plugin/plugin-hsa.c /^static struct hsa_context_info hsa_context;$/;" v typeref:struct:hsa_context_info file: +hsa_context_info plugin/plugin-hsa.c /^struct hsa_context_info$/;" s file: +hsa_error plugin/plugin-hsa.c /^hsa_error (const char *str, hsa_status_t status)$/;" f file: +hsa_executable_create_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_create_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_destroy_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_destroy_fn) (hsa_executable_t executable);$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_freeze_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_freeze_fn)(hsa_executable_t executable,$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_get_symbol_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_get_symbol_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_global_variable_define_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_global_variable_define_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_load_code_object_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_load_code_object_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_executable_symbol_get_info_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_executable_symbol_get_info_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_ext_control_directives_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_control_directives_s$/;" s +hsa_ext_control_directives_t plugin/hsa_ext_finalize.h /^} hsa_ext_control_directives_t;$/;" t typeref:struct:hsa_ext_control_directives_s +hsa_ext_finalizer_call_convention_t plugin/hsa_ext_finalize.h /^} hsa_ext_finalizer_call_convention_t;$/;" t typeref:enum:__anon17 +hsa_ext_image_capability_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_capability_t;$/;" t typeref:enum:__anon14 +hsa_ext_image_channel_order_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_channel_order_t;$/;" t typeref:enum:__anon12 +hsa_ext_image_channel_type_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_channel_type_t;$/;" t typeref:enum:__anon11 +hsa_ext_image_data_info_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_image_data_info_s$/;" s +hsa_ext_image_data_info_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_data_info_t;$/;" t typeref:struct:hsa_ext_image_data_info_s +hsa_ext_image_descriptor_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_image_descriptor_s$/;" s +hsa_ext_image_descriptor_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_descriptor_t;$/;" t typeref:struct:hsa_ext_image_descriptor_s +hsa_ext_image_format_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_image_format_s$/;" s +hsa_ext_image_format_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_format_t;$/;" t typeref:struct:hsa_ext_image_format_s +hsa_ext_image_geometry_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_geometry_t;$/;" t typeref:enum:__anon10 +hsa_ext_image_region_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_image_region_s$/;" s +hsa_ext_image_region_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_region_t;$/;" t typeref:struct:hsa_ext_image_region_s +hsa_ext_image_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_image_s$/;" s +hsa_ext_image_t plugin/hsa_ext_finalize.h /^} hsa_ext_image_t;$/;" t typeref:struct:hsa_ext_image_s +hsa_ext_module_t plugin/hsa_ext_finalize.h /^typedef BrigModule_t hsa_ext_module_t;$/;" t +hsa_ext_program_add_module_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_ext_program_add_module_fn) (hsa_ext_program_t program,$/;" m struct:hsa_runtime_fn_info file: +hsa_ext_program_create_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_ext_program_create_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_ext_program_destroy_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_ext_program_destroy_fn) (hsa_ext_program_t program);$/;" m struct:hsa_runtime_fn_info file: +hsa_ext_program_finalize_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_ext_program_finalize_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_ext_program_info_t plugin/hsa_ext_finalize.h /^} hsa_ext_program_info_t;$/;" t typeref:enum:__anon18 +hsa_ext_program_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_program_s$/;" s +hsa_ext_program_t plugin/hsa_ext_finalize.h /^} hsa_ext_program_t;$/;" t typeref:struct:hsa_ext_program_s +hsa_ext_sampler_addressing_mode_t plugin/hsa_ext_finalize.h /^} hsa_ext_sampler_addressing_mode_t;$/;" t typeref:enum:__anon13 +hsa_ext_sampler_coordinate_mode_t plugin/hsa_ext_finalize.h /^} hsa_ext_sampler_coordinate_mode_t;$/;" t typeref:enum:__anon16 +hsa_ext_sampler_descriptor_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_sampler_descriptor_s$/;" s +hsa_ext_sampler_descriptor_t plugin/hsa_ext_finalize.h /^} hsa_ext_sampler_descriptor_t;$/;" t typeref:struct:hsa_ext_sampler_descriptor_s +hsa_ext_sampler_filter_mode_t plugin/hsa_ext_finalize.h /^} hsa_ext_sampler_filter_mode_t;$/;" t typeref:enum:__anon15 +hsa_ext_sampler_s plugin/hsa_ext_finalize.h /^typedef struct hsa_ext_sampler_s$/;" s +hsa_ext_sampler_t plugin/hsa_ext_finalize.h /^} hsa_ext_sampler_t;$/;" t typeref:struct:hsa_ext_sampler_s +hsa_fatal plugin/plugin-hsa.c /^hsa_fatal (const char *str, hsa_status_t status)$/;" f file: +hsa_fns plugin/plugin-hsa.c /^static struct hsa_runtime_fn_info hsa_fns;$/;" v typeref:struct:hsa_runtime_fn_info file: +hsa_init_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_init_fn) (void);$/;" m struct:hsa_runtime_fn_info file: +hsa_iterate_agents_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_iterate_agents_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_kernel_description plugin/plugin-hsa.c /^struct hsa_kernel_description$/;" s file: +hsa_memory_allocate_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_memory_allocate_fn) (hsa_region_t region, size_t size,$/;" m struct:hsa_runtime_fn_info file: +hsa_memory_free_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_memory_free_fn) (void *ptr);$/;" m struct:hsa_runtime_fn_info file: +hsa_queue_add_write_index_release_fn plugin/plugin-hsa.c /^ uint64_t (*hsa_queue_add_write_index_release_fn) (const hsa_queue_t *queue,$/;" m struct:hsa_runtime_fn_info file: +hsa_queue_create_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_queue_create_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_queue_destroy_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_queue_destroy_fn) (hsa_queue_t *queue);$/;" m struct:hsa_runtime_fn_info file: +hsa_queue_load_read_index_acquire_fn plugin/plugin-hsa.c /^ uint64_t (*hsa_queue_load_read_index_acquire_fn) (const hsa_queue_t *queue);$/;" m struct:hsa_runtime_fn_info file: +hsa_region_get_info_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_region_get_info_fn) (hsa_region_t region,$/;" m struct:hsa_runtime_fn_info file: +hsa_runtime_fn_info plugin/plugin-hsa.c /^struct hsa_runtime_fn_info$/;" s file: +hsa_runtime_lib plugin/plugin-hsa.c /^static const char *hsa_runtime_lib;$/;" v file: +hsa_signal_create_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_signal_create_fn) (hsa_signal_value_t initial_value,$/;" m struct:hsa_runtime_fn_info file: +hsa_signal_destroy_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_signal_destroy_fn) (hsa_signal_t signal);$/;" m struct:hsa_runtime_fn_info file: +hsa_signal_load_acquire_fn plugin/plugin-hsa.c /^ hsa_signal_value_t (*hsa_signal_load_acquire_fn) (hsa_signal_t signal);$/;" m struct:hsa_runtime_fn_info file: +hsa_signal_store_relaxed_fn plugin/plugin-hsa.c /^ void (*hsa_signal_store_relaxed_fn) (hsa_signal_t signal,$/;" m struct:hsa_runtime_fn_info file: +hsa_signal_store_release_fn plugin/plugin-hsa.c /^ void (*hsa_signal_store_release_fn) (hsa_signal_t signal,$/;" m struct:hsa_runtime_fn_info file: +hsa_signal_wait_acquire_fn plugin/plugin-hsa.c /^ hsa_signal_value_t (*hsa_signal_wait_acquire_fn)$/;" m struct:hsa_runtime_fn_info file: +hsa_status_string_fn plugin/plugin-hsa.c /^ hsa_status_t (*hsa_status_string_fn) (hsa_status_t status,$/;" m struct:hsa_runtime_fn_info file: +hsa_warn plugin/plugin-hsa.c /^hsa_warn (const char *str, hsa_status_t status)$/;" f file: +htab hashtab.h /^struct htab {$/;" s +htab_alloc task.c /^htab_alloc (size_t size)$/;" f file: +htab_alloc tdg.c /^htab_alloc (size_t size)$/;" f file: +htab_clear_slot hashtab.h /^htab_clear_slot (htab_t htab, hash_entry_type *slot)$/;" f +htab_create hashtab.h /^htab_create (size_t size)$/;" f +htab_elements hashtab.h /^htab_elements (htab_t htab)$/;" f +htab_eq task.c /^htab_eq (hash_entry_type x, hash_entry_type y)$/;" f file: +htab_eq tdg.c /^htab_eq (hash_entry_type x, hash_entry_type y)$/;" f file: +htab_expand hashtab.h /^htab_expand (htab_t htab)$/;" f +htab_find hashtab.h /^htab_find (htab_t htab, const hash_entry_type element)$/;" f +htab_find_slot hashtab.h /^htab_find_slot (htab_t *htabp, const hash_entry_type element,$/;" f +htab_free task.c /^htab_free (void *ptr)$/;" f file: +htab_free tdg.c /^htab_free (void *ptr)$/;" f file: +htab_hash task.c /^htab_hash (hash_entry_type element)$/;" f file: +htab_hash tdg.c /^htab_hash (hash_entry_type element)$/;" f file: +htab_mod hashtab.h /^htab_mod (hashval_t hash, htab_t htab)$/;" f +htab_mod_1 hashtab.h /^htab_mod_1 (hashval_t x, hashval_t y, hashval_t inv, int shift)$/;" f +htab_mod_m2 hashtab.h /^htab_mod_m2 (hashval_t hash, htab_t htab)$/;" f +htab_size hashtab.h /^htab_size (htab_t htab)$/;" f +htab_t hashtab.h /^typedef struct htab *htab_t;$/;" t typeref:struct:htab +i testsuite/libgomp.c++/atomic-6.C /^int i, j;$/;" v +i testsuite/libgomp.c++/atomic-7.C /^int i, j;$/;" v +i testsuite/libgomp.c++/loop-6.C /^int i;$/;" v +i testsuite/libgomp.c++/master-1.C /^int i;$/;" v +i testsuite/libgomp.c++/pr24455-1.C /^int i;$/;" v +i testsuite/libgomp.c++/pr27337.C /^ int i;$/;" m struct:S file: +i testsuite/libgomp.c++/pr30703.C /^ int i;$/;" m struct:A file: +i testsuite/libgomp.c++/tls-init1.C /^ int i;$/;" m struct:A file: +i testsuite/libgomp.c/atomic-1.c /^ int i;$/;" m struct:__anon29 file: +i testsuite/libgomp.c/atomic-13.c /^int i, j;$/;" v +i testsuite/libgomp.c/loop-10.c /^int i = 8;$/;" v +i testsuite/libgomp.c/loop-16.c /^int i;$/;" v +i testsuite/libgomp.c/loop-3.c /^int i;$/;" v +i testsuite/libgomp.c/pr24455-1.c /^int i;$/;" v +i testsuite/libgomp.c/pr69110.c /^unsigned int i = 0;$/;" v +i testsuite/libgomp.c/simd-10.c /^int s = 0, i, u;$/;" v +i testsuite/libgomp.c/simd-11.c /^int s = 0, i, j, u;$/;" v +i testsuite/libgomp.fortran/affinity1.f90 /^ in/;" v +i testsuite/libgomp.fortran/alloc-comp-1.f90 /^ in/;" k type:dt +i testsuite/libgomp.fortran/alloc-comp-2.f90 /^ in/;" k type:dt +i testsuite/libgomp.fortran/alloc-comp-3.f90 /^ in/;" k type:dt +i testsuite/libgomp.fortran/allocatable1.f90 /^ in/;" v +i testsuite/libgomp.fortran/allocatable10.f90 /^ in/;" v +i testsuite/libgomp.fortran/allocatable3.f90 /^ in/;" v +i testsuite/libgomp.fortran/allocatable4.f90 /^ in/;" v +i testsuite/libgomp.fortran/allocatable6.f90 /^ in/;" v +i testsuite/libgomp.fortran/associate1.f90 /^ in/;" v program:associate1 +i testsuite/libgomp.fortran/associate2.f90 /^ in/;" k type:dl +i testsuite/libgomp.fortran/associate2.f90 /^ in/;" k type:dt +i testsuite/libgomp.fortran/associate2.f90 /^ in/;" v program:associate2 +i testsuite/libgomp.fortran/associate3.f90 /^ in/;" v +i testsuite/libgomp.fortran/cancel-do-1.f90 /^ in/;" v +i testsuite/libgomp.fortran/cancel-do-2.f90 /^ in/;" v +i testsuite/libgomp.fortran/cancel-parallel-3.f90 /^ in/;" v +i testsuite/libgomp.fortran/cancel-taskgroup-2.f90 /^ in/;" v +i testsuite/libgomp.fortran/character1.f90 /^ character (len = 8) :: h, i$/;" v +i testsuite/libgomp.fortran/character2.f90 /^ character (len = 9) :: i$/;" v +i testsuite/libgomp.fortran/collapse1.f90 /^ in/;" v program:collapse1 +i testsuite/libgomp.fortran/collapse4.f90 /^ in/;" v +i testsuite/libgomp.fortran/crayptr3.f90 /^ in/;" v +i testsuite/libgomp.fortran/declare-simd-1.f90 /^ in/;" v +i testsuite/libgomp.fortran/do1.f90 /^ in/;" v +i testsuite/libgomp.fortran/do2.f90 /^ in/;" v +i testsuite/libgomp.fortran/doacross1.f90 /^ in/;" v +i testsuite/libgomp.fortran/doacross2.f90 /^ in/;" v +i testsuite/libgomp.fortran/doacross3.f90 /^ in/;" v +i testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^ in/;" v program:e_53_4 +i testsuite/libgomp.fortran/examples-4/device-2.f90 /^ in/;" v program:e_57_2 +i testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ in/;" v program:main +i testsuite/libgomp.fortran/examples-4/simd-7.f90 /^ in/;" v program:fibonacci +i testsuite/libgomp.fortran/examples-4/simd-8.f90 /^ in/;" v program:simd_8f +i testsuite/libgomp.fortran/lastprivate1.f90 /^ in/;" v program:lastprivate +i testsuite/libgomp.fortran/lastprivate2.f90 /^ in/;" v program:lastprivate +i testsuite/libgomp.fortran/nestedfn2.f90 /^ in/;" v +i testsuite/libgomp.fortran/nestedfn4.f90 /^ in/;" v program:foo +i testsuite/libgomp.fortran/omp_atomic2.f90 /^ in/;" v +i testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ in/;" v program:main +i testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ in/;" v program:main +i testsuite/libgomp.fortran/pointer2.f90 /^ in/;" v +i testsuite/libgomp.fortran/pr25219.f90 /^ in/;" v +i testsuite/libgomp.fortran/pr27395-1.f90 /^ in/;" v program:pr27395_1 +i testsuite/libgomp.fortran/pr27395-2.f90 /^ in/;" v program:pr27395_2 +i testsuite/libgomp.fortran/pr27916-1.f90 /^ in/;" v program:pr27916 +i testsuite/libgomp.fortran/pr27916-2.f90 /^ in/;" v program:pr27916 +i testsuite/libgomp.fortran/pr28390.f /^ in/;" v program:pr28390 +i testsuite/libgomp.fortran/pr33880.f90 /^ in/;" v program:pr33880 +i testsuite/libgomp.fortran/pr34020.f90 /^ in/;" v +i testsuite/libgomp.fortran/pr46753.f90 /^ in/;" v +i testsuite/libgomp.fortran/pr63938-1.f90 /^ in/;" v program:pr63938_1 +i testsuite/libgomp.fortran/pr63938-2.f90 /^ in/;" v program:pr63938_2 +i testsuite/libgomp.fortran/pr65597.f90 /^ in/;" v +i testsuite/libgomp.fortran/pr71014.f90 /^ in/;" v program:pr71014 +i testsuite/libgomp.fortran/pr81304.f90 /^ in/;" v program:pr81304 +i testsuite/libgomp.fortran/recursion1.f90 /^in/;" v +i testsuite/libgomp.fortran/reduction1.f90 /^ in/;" v +i testsuite/libgomp.fortran/reduction3.f90 /^ in/;" v +i testsuite/libgomp.fortran/reduction4.f90 /^ in/;" v +i testsuite/libgomp.fortran/reference1.f90 /^ in/;" v +i testsuite/libgomp.fortran/sharing1.f90 /^ in/;" v +i testsuite/libgomp.fortran/sharing2.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd1.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd2.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd3.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd4.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd5.f90 /^ in/;" v +i testsuite/libgomp.fortran/simd6.f90 /^ in/;" v +i testsuite/libgomp.fortran/target1.f90 /^ in/;" v +i testsuite/libgomp.fortran/target4.f90 /^ in/;" v +i testsuite/libgomp.fortran/target6.f90 /^ in/;" v +i testsuite/libgomp.fortran/target7.f90 /^ in/;" v +i testsuite/libgomp.fortran/target8.f90 /^ in/;" v +i testsuite/libgomp.fortran/task1.f90 /^ in/;" v program:tasktest +i testsuite/libgomp.fortran/taskgroup1.f90 /^ in/;" v +i testsuite/libgomp.fortran/taskloop2.f90 /^ in/;" v +i testsuite/libgomp.fortran/taskloop3.f90 /^ in/;" v +i testsuite/libgomp.fortran/threadprivate4.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr1.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr10.f90 /^ in/;" v program:udr10 +i testsuite/libgomp.fortran/udr11.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr15.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr2.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr3.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr4.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr6.f90 /^ in/;" v program:udr6 +i testsuite/libgomp.fortran/udr7.f90 /^ in/;" v program:udr7 +i testsuite/libgomp.fortran/udr8.f90 /^ in/;" v +i testsuite/libgomp.fortran/udr9.f90 /^ in/;" v +i testsuite/libgomp.hsa.c/alloca-1.c /^int i, j, k;$/;" v +i testsuite/libgomp.hsa.c/memory-operations-1.c /^int i, j, k;$/;" v +i testsuite/libgomp.oacc-c-c++-common/data-1.c /^int i;$/;" v +i testsuite/libgomp.oacc-c-c++-common/data-clauses.h /^int i;$/;" v +i testsuite/libgomp.oacc-fortran/asyncwait-1.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/asyncwait-2.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/asyncwait-3.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/clauses-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/collapse-1.f90 /^ in/;" v program:collapse1 +i testsuite/libgomp.oacc-fortran/collapse-2.f90 /^ in/;" v program:collapse2 +i testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ in/;" v program:collapse4 +i testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ in/;" v program:collapse5 +i testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ in/;" v program:collapse6 +i testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ in/;" v program:collapse7 +i testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ in/;" v program:collapse8 +i testsuite/libgomp.oacc-fortran/combined-directives-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/combined-reduction.f90 /^ in/;" v program:test +i testsuite/libgomp.oacc-fortran/data-3.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/data-4-2.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/data-4.f90 /^ in/;" v program:asyncwait +i testsuite/libgomp.oacc-fortran/declare-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/host_data-1.f90 /^ in/;" v program:test +i testsuite/libgomp.oacc-fortran/if-1.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/lib-10.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/lib-8.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/map-1.f90 /^ in/;" v +i testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/pr68813.f90 /^ in/;" v program:foo +i testsuite/libgomp.oacc-fortran/pr70289.f90 /^ in/;" v program:foo +i testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ in/;" v program:reduction_1 +i testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ in/;" v program:reduction_2 +i testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ in/;" v program:reduction_3 +i testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ in/;" v program:reduction_4 +i testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ in/;" v program:reduction +i testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ in/;" v program:reduction +i testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ in/;" v program:reduction +i testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ in/;" v program:reduction +i testsuite/libgomp.oacc-fortran/routine-1.f90 /^ in/;" v +i testsuite/libgomp.oacc-fortran/routine-2.f90 /^ in/;" v +i testsuite/libgomp.oacc-fortran/routine-3.f90 /^ in/;" v +i testsuite/libgomp.oacc-fortran/routine-4.f90 /^ in/;" v +i testsuite/libgomp.oacc-fortran/routine-7.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/routine-9.f90 /^ in/;" v program:main +i testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^ in/;" v program:subarrays +i testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ in/;" v program:subarrays +i testsuite/libgomp.oacc-fortran/update-1.f90 /^ in/;" v program:update +i4 testsuite/libgomp.fortran/udr5.f90 /^ integer (kind = 4) :: i4$/;" v program:udr5 +i4 testsuite/libgomp.fortran/udr6.f90 /^ integer (kind = 4), allocatable, dimension(:) :: i4$/;" v program:udr6 +i8 testsuite/libgomp.fortran/udr5.f90 /^ integer (kind = 8) :: i8$/;" v program:udr5 +i8 testsuite/libgomp.fortran/udr6.f90 /^ integer (kind = 8), allocatable, dimension(:,:) :: i8$/;" v program:udr6 +i9 testsuite/libgomp.c++/for-5.C /^I i9;$/;" v +i9 testsuite/libgomp.c++/taskloop-9.C /^I i9;$/;" v +i_size testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer, parameter :: i_size /;" v program:main +i_size testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer, parameter :: i_size /;" v program:main +ia testsuite/libgomp.fortran/reduction1.f90 /^ integer :: i, ia /;" v +ia testsuite/libgomp.fortran/reduction3.f90 /^ integer (kind = 4) :: i, ia /;" v +ia testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia /;" v +ialias libgomp.h 1131;" d +ialias libgomp.h 1138;" d +ialias oacc-init.c /^ialias (acc_get_device_num)$/;" f +ialias oacc-init.c /^ialias (acc_get_device_type)$/;" f +ialias oacc-init.c /^ialias (acc_get_num_devices)$/;" f +ialias oacc-init.c /^ialias (acc_init)$/;" f +ialias oacc-init.c /^ialias (acc_on_device)$/;" f +ialias oacc-init.c /^ialias (acc_set_device_num)$/;" f +ialias oacc-init.c /^ialias (acc_set_device_type)$/;" f +ialias oacc-init.c /^ialias (acc_shutdown)$/;" f +ialias parallel.c /^ialias (GOMP_cancellation_point)$/;" f +ialias parallel.c /^ialias (GOMP_parallel_end)$/;" f +ialias_call libgomp.h 1136;" d +ialias_call libgomp.h 1140;" d +ialias_redirect fortran.c /^ialias_redirect (omp_init_lock)$/;" f +ialias_redirect libgomp.h 1134;" d +ialias_redirect libgomp.h 1139;" d +ialias_redirect loop.c /^ialias_redirect (GOMP_parallel_end)$/;" f +ialias_redirect sections.c /^ialias_redirect (GOMP_parallel_end)$/;" f +ialias_str1 libgomp.h 1129;" d +ialias_str2 libgomp.h 1130;" d +ialias_ulp libgomp.h 1128;" d +ic testsuite/libgomp.c++/ctor-13.C /^ static int ic, dc, xc, ac, cc;$/;" m struct:B file: +ic testsuite/libgomp.c++/ctor-13.C /^int B::ic;$/;" m class:B file: +icount testsuite/libgomp.c++/ctor-1.C /^ static int icount;$/;" m struct:B file: +icount testsuite/libgomp.c++/ctor-1.C /^int B::icount;$/;" m class:B file: +icount testsuite/libgomp.c++/ctor-11.C /^ static int icount;$/;" m struct:B file: +icount testsuite/libgomp.c++/ctor-11.C /^int B::icount;$/;" m class:B file: +icount testsuite/libgomp.c++/ctor-3.C /^ static int icount;$/;" m struct:B file: +icount testsuite/libgomp.c++/ctor-3.C /^int B::icount;$/;" m class:B file: +icount testsuite/libgomp.c++/ctor-7.C /^ static int icount;$/;" m struct:B file: +icount testsuite/libgomp.c++/ctor-7.C /^int B::icount;$/;" m class:B file: +icv libgomp.h /^ struct gomp_task_icv icv;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_task_icv +id plugin/plugin-hsa.c /^ hsa_agent_t id;$/;" m struct:agent_info file: +id tdg.h /^ unsigned long int id; \/\/ Task instance ID$/;" m struct:gomp_tdg_node +id testsuite/libgomp.fortran/stack.f90 /^ integer id$/;" v program:stack +idat testsuite/libgomp.fortran/jacobi.f 33;" c program:main +idat testsuite/libgomp.fortran/jacobi.f 84;" c subroutine:driver +identity testsuite/libgomp.hsa.c/function-call-1.c /^identity (int x)$/;" f +iexp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ integer igot, iexp,/;" v program:main +iexp testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ integer igot, iexp,/;" v program:main +iexpr testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ integer igot, iexp, iexpr$/;" v program:main +igot testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ integer igot,/;" v program:main +igot testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ integer igot,/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ integer :: i, ii$/;" v program:main +ii testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ integer :: i, ii$/;" v program:main +ilocs testsuite/libgomp.fortran/stack.f90 /^ integer ilocs(/;" v program:stack +image plugin/plugin-hsa.c /^ hsa_ext_module_t image;$/;" m struct:brig_library_info file: +image_desc plugin/plugin-hsa.c /^ struct brig_image_desc *image_desc;$/;" m struct:module_info typeref:struct:module_info::brig_image_desc file: +image_lock plugin/plugin-nvptx.c /^ pthread_mutex_t image_lock; \/* Lock for above list. *\/$/;" m struct:ptx_device file: +images plugin/plugin-nvptx.c /^ struct ptx_image_data *images; \/* Images loaded on device. *\/$/;" m struct:ptx_device typeref:struct:ptx_device::ptx_image_data file: +implicit_task libgomp.h /^ struct gomp_task implicit_task[];$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_task +in_depend_wait libgomp.h /^ bool in_depend_wait;$/;" m struct:gomp_taskwait +in_taskgroup_wait libgomp.h /^ bool in_taskgroup_wait;$/;" m struct:gomp_taskgroup +in_taskwait libgomp.h /^ bool in_taskwait;$/;" m struct:gomp_taskwait +in_tied_task libgomp.h /^ bool in_tied_task;$/;" m struct:gomp_task +in_tied_task libgomp.h /^ bool in_tied_task;$/;" m struct:gomp_tdg_task +incr libgomp.h /^ long incr;$/;" m struct:gomp_work_share::__anon46::__anon47 +incr testsuite/libgomp.oacc-fortran/routine-4.f90 /^subroutine incr /;" s +incr_a testsuite/libgomp.c/appendix-a/a.40.1.c /^incr_a (pair * p, int a)$/;" f +incr_b testsuite/libgomp.c/appendix-a/a.40.1.c /^incr_b (pair * p, int b)$/;" f +incr_pair testsuite/libgomp.c/appendix-a/a.40.1.c /^incr_pair (pair * p, int a, int b)$/;" f +incr_ull libgomp.h /^ unsigned long long incr_ull;$/;" m struct:gomp_work_share::__anon46::__anon48 +indent_stream plugin/plugin-hsa.c /^indent_stream (FILE *f, unsigned indent)$/;" f file: +index config/rtems/pool.h /^ size_t index;$/;" m struct:gomp_thread_pool_reservoir +init testsuite/libgomp.c++/examples-4/target_data-5.C /^void init (float *a1, float *a2, int n)$/;" f +init testsuite/libgomp.c/examples-4/async_target-1.c /^void init ()$/;" f +init testsuite/libgomp.c/examples-4/async_target-2.c /^void init (float *a, float *b, int n)$/;" f +init testsuite/libgomp.c/examples-4/declare_target-3.c /^void init ()$/;" f +init testsuite/libgomp.c/examples-4/declare_target-4.c /^void init ()$/;" f +init testsuite/libgomp.c/examples-4/declare_target-5.c /^void init ()$/;" f +init testsuite/libgomp.c/examples-4/simd-1.c /^void init(double *a, double *a_ref, double *b, double *c, int n, int ioff)$/;" f +init testsuite/libgomp.c/examples-4/simd-2.c /^void init(double *a, double *a_ref, double *b, int n)$/;" f +init testsuite/libgomp.c/examples-4/simd-3.c /^void init(double *a, double *a_ref, double *b, int n)$/;" f +init testsuite/libgomp.c/examples-4/simd-4.c /^void init(double *a, double *b, int n)$/;" f +init testsuite/libgomp.c/examples-4/simd-5.c /^void init(double a[N][N], double b[N][N], int n)$/;" f +init testsuite/libgomp.c/examples-4/simd-6.c /^void init(int *b, float *y, int n)$/;" f +init testsuite/libgomp.c/examples-4/target-1.c /^void init (int *a1, int *a2)$/;" f +init testsuite/libgomp.c/examples-4/target-2.c /^void init (char *a1, char *a2)$/;" f +init testsuite/libgomp.c/examples-4/target-3.c /^void init (long long *a1, long long *a2)$/;" f +init testsuite/libgomp.c/examples-4/target-4.c /^void init (double *a1, double *a2)$/;" f +init testsuite/libgomp.c/examples-4/target-5.c /^void init (float *a1, float *a2)$/;" f +init testsuite/libgomp.c/examples-4/target_data-1.c /^void init (long long *a1, long long *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_data-2.c /^void init (char *a1, char *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_data-3.c /^void init (int Q[][COLS], const int rows, const int cols)$/;" f +init testsuite/libgomp.c/examples-4/target_data-4.c /^void init (double *a1, double *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_data-6.c /^void init (float *a1, float *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_data-7.c /^void init (short *a1, short *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_update-1.c /^void init (int *a1, int *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/target_update-2.c /^void init (int *a1, int *a2, int N)$/;" f +init testsuite/libgomp.c/examples-4/task_dep-5.c /^void init (float A[N][N], float B[N][N])$/;" f +init testsuite/libgomp.c/examples-4/teams-2.c /^void init (float B[], float C[], int n)$/;" f +init testsuite/libgomp.c/examples-4/teams-3.c /^void init (float B[], float C[], int n)$/;" f +init testsuite/libgomp.c/examples-4/teams-4.c /^void init (float B[], float C[], int n)$/;" f +init testsuite/libgomp.c/examples-4/teams-5.c /^void init (float *a, float *b, int n)$/;" f +init testsuite/libgomp.c/examples-4/teams-6.c /^void init (float *a, float *b, int n)$/;" f +init testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^init (void)$/;" f file: +init testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^init (void)$/;" f file: +init testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^init (void)$/;" f file: +init testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^init (void)$/;" f file: +init testsuite/libgomp.c/pr46032.c /^init (unsigned *results, unsigned *pData)$/;" f file: +init testsuite/libgomp.c/pr46193.c /^init (char **list)$/;" f file: +init testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/declare_target-4.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/declare_target-5.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ subroutine init /;" s module:SIMD1_mod +init testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ subroutine init /;" s module:SIMD3_mod +init testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ subroutine init /;" s module:SIMD4_mod +init testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ subroutine init /;" s module:SIMD5_mod +init testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ subroutine init /;" s module:SIMD6_mod +init testsuite/libgomp.fortran/examples-4/target-1.f90 /^ subroutine init /;" s module:e_50_1_mod +init testsuite/libgomp.fortran/examples-4/target-2.f90 /^ subroutine init /;" s module:e_50_2_mod +init testsuite/libgomp.fortran/examples-4/target-3.f90 /^ subroutine init /;" s module:e_50_3_mod +init testsuite/libgomp.fortran/examples-4/target-4.f90 /^ subroutine init /;" s module:e_50_4_mod +init testsuite/libgomp.fortran/examples-4/target-5.f90 /^ subroutine init /;" s module:e_50_5_mod +init testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^ subroutine init /;" s module:e_51_1_mod +init testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^ subroutine init /;" s module:e_51_2_mod +init testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ subroutine init /;" s module:e_51_3_mod +init testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ subroutine init /;" s module:e_51_4_mod +init testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ subroutine init /;" s module:e_51_5_mod +init testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^ subroutine init /;" s module:e_51_6_mod +init testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^ subroutine init /;" s module:e_51_7_mod +init testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ subroutine init /;" s module:e_52_1_mod +init testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ subroutine init /;" s module:e_52_2_mod +init testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ subroutine init /;" s module:task_dep5_mod +init testsuite/libgomp.fortran/examples-4/teams-2.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/teams-3.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/teams-4.f90 /^subroutine init /;" s +init testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ subroutine init /;" s module:e_54_5_mod +init testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ subroutine init /;" s module:e_54_6_mod +init testsuite/libgomp.graphite/force-parallel-6.c /^init (void)$/;" f file: +init testsuite/libgomp.hsa.c/function-call-1.c /^init (int x, int y)$/;" f +init2 testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ subroutine init2 /;" s module:SIMD6_mod +init_again testsuite/libgomp.c/examples-4/target_data-2.c /^void init_again (char *a1, char *a2, int N)$/;" f +init_again testsuite/libgomp.c/examples-4/target_data-6.c /^void init_again (float *a1, float *a2, int N)$/;" f +init_again testsuite/libgomp.c/examples-4/target_update-1.c /^void init_again (int *a1, int *a2, int N)$/;" f +init_again testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^ subroutine init_again /;" s module:e_51_2_mod +init_again testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^ subroutine init_again /;" s module:e_51_6_mod +init_again testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ subroutine init_again /;" s module:e_52_1_mod +init_again testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ subroutine init_again /;" s module:e_52_2_mod +init_basic_kernel_info plugin/plugin-hsa.c /^init_basic_kernel_info (struct kernel_info *kernel,$/;" f file: +init_cuda_lib plugin/plugin-nvptx.c /^init_cuda_lib (void)$/;" f file: +init_cuda_lib plugin/plugin-nvptx.c 138;" d file: +init_device_func libgomp.h /^ __typeof (GOMP_OFFLOAD_init_device) *init_device_func;$/;" m struct:gomp_device_descr +init_enviroment_variables plugin/plugin-hsa.c /^init_enviroment_variables (void)$/;" f file: +init_hsa_context plugin/plugin-hsa.c /^init_hsa_context (void)$/;" f file: +init_hsa_runtime_functions plugin/plugin-hsa.c /^init_hsa_runtime_functions (void)$/;" f file: +init_int_pair_stack testsuite/libgomp.c/sort-1.c /^init_int_pair_stack (struct int_pair_stack *stack)$/;" f file: +init_kernel plugin/plugin-hsa.c /^init_kernel (struct kernel_info *kernel)$/;" f file: +init_mutex plugin/plugin-hsa.c /^ pthread_mutex_t init_mutex;$/;" m struct:kernel_info file: +init_single_kernel plugin/plugin-hsa.c /^init_single_kernel (struct kernel_info *kernel, unsigned *max_omp_data_size)$/;" f file: +init_streams_for_device plugin/plugin-nvptx.c /^init_streams_for_device (struct ptx_device *ptx_dev, int concurrency)$/;" f file: +init_tdg_func_hash_tab tdg.h /^static tdg_hash_table *init_tdg_func_hash_tab()$/;" f +init_tdg_node tdg.c /^void init_tdg_node (struct gomp_tdg_node *tdg_node, struct gomp_tdg_task *tdg_task)$/;" f +init_tdg_task tdg.c /^void init_tdg_task (struct gomp_tdg_task *tdg_task, struct gomp_tdg_node *tdg_node,$/;" f +init_thread_pool_reservoirs config/rtems/proc.c /^init_thread_pool_reservoirs (void)$/;" f file: +init_timers testsuite/libgomp.oacc-c-c++-common/timer.h /^init_timers (int ntimers)$/;" f +init_zero testsuite/libgomp.c/examples-4/task_dep-5.c /^void init_zero (float A[N][N], float B[N][N])$/;" f +initialization_failed plugin/plugin-hsa.c /^ bool initialization_failed;$/;" m struct:kernel_info file: +initialize testsuite/libgomp.fortran/jacobi.f /^ subroutine initialize /;" s +initialize_atomic atomic.c /^initialize_atomic (void)$/;" f file: +initialize_critical critical.c /^initialize_critical (void)$/;" f file: +initialize_env env.c /^initialize_env (void)$/;" f file: +initialize_team team.c /^initialize_team (void)$/;" f file: +initialized plugin/plugin-hsa.c /^ bool initialized;$/;" m struct:agent_info file: +initialized plugin/plugin-hsa.c /^ bool initialized;$/;" m struct:hsa_context_info file: +initialized plugin/plugin-hsa.c /^ bool initialized;$/;" m struct:kernel_info file: +initializer1 testsuite/libgomp.fortran/udr9.f90 /^ subroutine initializer1 /;" s module:udr9m1 +initializer2 testsuite/libgomp.fortran/udr9.f90 /^ subroutine initializer2 /;" s module:udr9m2 +inline_ordered_team_ids libgomp.h /^ unsigned inline_ordered_team_ids[0];$/;" m struct:gomp_work_share +inner testsuite/libgomp.fortran/pr35130.f90 /^ subroutine inner(/;" s program:pr35130 +insert_option hashtab.h /^enum insert_option {NO_INSERT, INSERT};$/;" g +insertsort testsuite/libgomp.c/sort-1.c /^insertsort (int *array, int s, int e)$/;" f file: +instantiated_devices plugin/plugin-nvptx.c /^static unsigned int instantiated_devices = 0;$/;" v file: +int_pair testsuite/libgomp.c/sort-1.c /^struct int_pair$/;" s file: +int_pair_stack testsuite/libgomp.c/sort-1.c /^struct int_pair_stack$/;" s file: +inv hashtab.h /^ hashval_t inv;$/;" m struct:prime_ent +inv_m2 hashtab.h /^ hashval_t inv_m2; \/* inverse of prime-2 *\/$/;" m struct:prime_ent +ioff_ptr testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ integer, pointer:: ioff_ptr$/;" v program:SIMD1 +ip testsuite/libgomp.oacc-fortran/host_data-1.f90 /^ integer, pointer :: ip,/;" v program:test +iph testsuite/libgomp.oacc-fortran/host_data-1.f90 /^ integer, pointer :: ip, iph$/;" v program:test +is_in libgomp.h /^ bool is_in;$/;" m struct:gomp_task_depend_entry +is_mapped testsuite/libgomp.oacc-c-c++-common/data-1.c /^is_mapped (void *p, size_t n)$/;" f +isa plugin/plugin-hsa.c /^ hsa_isa_t isa;$/;" m struct:agent_info file: +iterator testsuite/libgomp.c++/for-4.C /^ typedef typename std::basic_string::iterator iterator;$/;" t class:J file: +iterator testsuite/libgomp.c++/taskloop-8.C /^ typedef typename std::basic_string::iterator iterator;$/;" t class:J file: +itmp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ integer igot, iexp, itmp$/;" v program:main +j testsuite/libgomp.c++/atomic-6.C /^int i, j;$/;" v +j testsuite/libgomp.c++/atomic-7.C /^int i, j;$/;" v +j testsuite/libgomp.c++/task-3.C /^int j;$/;" v +j testsuite/libgomp.c++/task-5.C /^int j;$/;" v +j testsuite/libgomp.c++/tls-init1.C /^int j;$/;" v +j testsuite/libgomp.c/atomic-1.c /^ int j;$/;" m struct:__anon29 file: +j testsuite/libgomp.c/atomic-13.c /^int i, j;$/;" v +j testsuite/libgomp.c/nestedfn-6.c /^int j;$/;" v +j testsuite/libgomp.c/pr26943-2.c /^int a = 8, b = 12, c = 16, d = 20, j = 0;$/;" v +j testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +j testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +j testsuite/libgomp.c/reduction-6.c /^int j;$/;" v +j testsuite/libgomp.c/simd-11.c /^int s = 0, i, j, u;$/;" v +j testsuite/libgomp.fortran/alloc-comp-1.f90 /^ type (dl) :: j(/;" k type:dt +j testsuite/libgomp.fortran/alloc-comp-2.f90 /^ type (dl) :: j(/;" k type:dt +j testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type (dl) :: j(/;" k type:dt +j testsuite/libgomp.fortran/allocatable1.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/allocatable4.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/allocatable6.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/associate1.f90 /^ integer :: v, i, j$/;" v program:associate1 +j testsuite/libgomp.fortran/associate2.f90 /^ integer :: v(4), i, j,/;" v program:associate2 +j testsuite/libgomp.fortran/associate3.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/cancel-parallel-3.f90 /^ integer :: x, i, j$/;" v +j testsuite/libgomp.fortran/character1.f90 /^ character (len = 4) :: j,/;" v +j testsuite/libgomp.fortran/collapse1.f90 /^ integer :: i, j,/;" v program:collapse1 +j testsuite/libgomp.fortran/collapse4.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/do2.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/doacross1.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/doacross2.f90 /^ integer :: j,/;" v +j testsuite/libgomp.fortran/doacross3.f90 /^ integer :: j,/;" v +j testsuite/libgomp.fortran/nestedfn3.f90 /^ integer :: j$/;" v program:nestomp +j testsuite/libgomp.fortran/nestedfn4.f90 /^ integer :: i, j,/;" v program:foo +j testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer :: i, j,/;" v program:main +j testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer :: i, j,/;" v program:main +j testsuite/libgomp.fortran/pr27416-1.f90 /^ integer :: j$/;" v +j testsuite/libgomp.fortran/pr33880.f90 /^ integer :: i, j$/;" v program:pr33880 +j testsuite/libgomp.fortran/pr46753.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/pr71014.f90 /^ integer :: i, j$/;" v program:pr71014 +j testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j,/;" v +j testsuite/libgomp.fortran/reference1.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/sharing1.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/sharing2.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/simd1.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/simd5.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/simd6.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/target4.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/target7.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/target8.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/task1.f90 /^ integer :: i, j$/;" v program:tasktest +j testsuite/libgomp.fortran/udr1.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/udr10.f90 /^ type(dl) :: j,/;" v program:udr10 +j testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j,/;" v +j testsuite/libgomp.fortran/udr15.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/udr2.f90 /^ integer :: i, j(/;" v +j testsuite/libgomp.fortran/udr4.f90 /^ integer :: i, j,/;" v +j testsuite/libgomp.fortran/udr8.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.fortran/udr9.f90 /^ integer :: i, j$/;" v +j testsuite/libgomp.hsa.c/alloca-1.c /^int i, j, k;$/;" v +j testsuite/libgomp.hsa.c/memory-operations-1.c /^int i, j, k;$/;" v +j testsuite/libgomp.oacc-fortran/collapse-1.f90 /^ integer :: i, j,/;" v program:collapse1 +j testsuite/libgomp.oacc-fortran/collapse-2.f90 /^ integer :: i, j,/;" v program:collapse2 +j testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ integer :: i, j,/;" v program:collapse4 +j testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: i, j,/;" v program:collapse5 +j testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: i, j,/;" v program:collapse6 +j testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ integer :: i, j,/;" v program:collapse7 +j testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: i, j,/;" v program:collapse8 +j testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer i, j,/;" v program:main +j testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer i, j,/;" v program:main +j testsuite/libgomp.oacc-fortran/pr68813.f90 /^ integer :: i, j,/;" v program:foo +j testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: j,/;" v program:reduction +j testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ integer :: i, j,/;" v program:reduction +ja testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j, ja /;" v +jacobi testsuite/libgomp.fortran/jacobi.f /^ subroutine jacobi /;" s +ji testsuite/libgomp.c/loop-13.c /^volatile int ji = 100, ki = 2;$/;" v +ji testsuite/libgomp.c/loop-14.c /^volatile int ji = 100, ki = 2;$/;" v +ji testsuite/libgomp.c/loop-15.c /^volatile int ji = 100, ki = 2;$/;" v +jll testsuite/libgomp.c/loop-13.c /^volatile long long int jll = 100, kll = 2;$/;" v +jll testsuite/libgomp.c/loop-14.c /^volatile long long int jll = 100, kll = 2;$/;" v +jll testsuite/libgomp.c/loop-15.c /^volatile long long int jll = 100, kll = 2;$/;" v +ju testsuite/libgomp.c/loop-13.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +ju testsuite/libgomp.c/loop-14.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +ju testsuite/libgomp.c/loop-15.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +jull testsuite/libgomp.c/loop-13.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +jull testsuite/libgomp.c/loop-14.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +jull testsuite/libgomp.c/loop-15.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +k testsuite/libgomp.c++/simd-1.C /^int k, m;$/;" v +k testsuite/libgomp.c++/simd-3.C /^int k, m;$/;" v +k testsuite/libgomp.c/pr26943-3.c /^volatile int k;$/;" v +k testsuite/libgomp.c/pr26943-4.c /^volatile int k;$/;" v +k testsuite/libgomp.c/simd-1.c /^int k, m;$/;" v +k testsuite/libgomp.c/simd-3.c /^int k, m;$/;" v +k testsuite/libgomp.c/simd-7.c /^int k, m;$/;" v +k testsuite/libgomp.fortran/alloc-comp-1.f90 /^ type (dl), allocatable :: k$/;" k type:dt +k testsuite/libgomp.fortran/alloc-comp-2.f90 /^ type (dl), allocatable :: k$/;" k type:dt +k testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type (dl), allocatable :: k$/;" k type:dt +k testsuite/libgomp.fortran/allocatable1.f90 /^ logical :: k,/;" v +k testsuite/libgomp.fortran/allocatable4.f90 /^ logical :: k,/;" v +k testsuite/libgomp.fortran/associate2.f90 /^ integer :: v(4), i, j, k,/;" v program:associate2 +k testsuite/libgomp.fortran/character1.f90 /^ character (len = 4) :: j, k$/;" v +k testsuite/libgomp.fortran/collapse1.f90 /^ integer :: i, j, k,/;" v program:collapse1 +k testsuite/libgomp.fortran/collapse4.f90 /^ integer :: i, j, k$/;" v +k testsuite/libgomp.fortran/do2.f90 /^ logical :: k$/;" v +k testsuite/libgomp.fortran/doacross1.f90 /^ integer :: i, j, k,/;" v +k testsuite/libgomp.fortran/doacross2.f90 /^ integer :: j, k,/;" v +k testsuite/libgomp.fortran/doacross3.f90 /^ integer :: j, k,/;" v +k testsuite/libgomp.fortran/lastprivate2.f90 /^ integer :: i, k$/;" v program:lastprivate +k testsuite/libgomp.fortran/nestedfn4.f90 /^ integer :: i, j, k$/;" v program:foo +k testsuite/libgomp.fortran/omp_atomic2.f90 /^ integer :: i, j, k,/;" v +k testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ integer :: i, j, k$/;" v program:main +k testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ integer :: i, j, k$/;" v program:main +k testsuite/libgomp.fortran/pr25219.f90 /^ integer :: i, k$/;" v +k testsuite/libgomp.fortran/pr35130.f90 /^ integer :: k$/;" v program:pr35130 +k testsuite/libgomp.fortran/pr42162.f90 /^ integer :: k,/;" v program:pr42162 +k testsuite/libgomp.fortran/reduction4.f90 /^ integer (ki/;" v +k testsuite/libgomp.fortran/reference1.f90 /^ integer :: i, j, k$/;" v +k testsuite/libgomp.fortran/sharing1.f90 /^ integer :: i, j, k$/;" v +k testsuite/libgomp.fortran/sharing2.f90 /^ integer :: i, j, k,/;" v +k testsuite/libgomp.fortran/simd1.f90 /^ integer :: i, j, k,/;" v +k testsuite/libgomp.fortran/simd2.f90 /^ integer :: a(1024), b(1024), k,/;" v +k testsuite/libgomp.fortran/simd3.f90 /^ integer :: a(1024), b(1024), k,/;" v +k testsuite/libgomp.fortran/simd4.f90 /^ integer :: a(1024), b(1024), k,/;" v +k testsuite/libgomp.fortran/udr10.f90 /^ type(dl) :: j, k$/;" v program:udr10 +k testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k,/;" v +k testsuite/libgomp.fortran/udr4.f90 /^ integer :: i, j, k$/;" v +k testsuite/libgomp.hsa.c/alloca-1.c /^int i, j, k;$/;" v +k testsuite/libgomp.hsa.c/memory-operations-1.c /^int i, j, k;$/;" v +k testsuite/libgomp.oacc-fortran/collapse-1.f90 /^ integer :: i, j, k,/;" v program:collapse1 +k testsuite/libgomp.oacc-fortran/collapse-2.f90 /^ integer :: i, j, k,/;" v program:collapse2 +k testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k,/;" v program:collapse3 +k testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ integer :: i, j, k,/;" v program:collapse4 +k testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: i, j, k,/;" v program:collapse5 +k testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: i, j, k,/;" v program:collapse6 +k testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ integer :: i, j, k,/;" v program:collapse7 +k testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: i, j, k,/;" v program:collapse8 +k testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer i, j, k$/;" v program:main +k testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer i, j, k$/;" v program:main +ka testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j, ja (6), k, ka /;" v +kernarg_address plugin/plugin-hsa.c /^ void *kernarg_address;$/;" m struct:GOMP_hsa_kernel_dispatch file: +kernarg_region plugin/plugin-hsa.c /^ hsa_region_t kernarg_region;$/;" m struct:agent_info file: +kernarg_segment_size plugin/plugin-hsa.c /^ uint32_t kernarg_segment_size;$/;" m struct:kernel_info file: +kernel_count plugin/plugin-hsa.c /^ const unsigned kernel_count;$/;" m struct:brig_image_desc file: +kernel_count plugin/plugin-hsa.c /^ int kernel_count;$/;" m struct:module_info file: +kernel_dependencies plugin/plugin-hsa.c /^ const char **kernel_dependencies;$/;" m struct:hsa_kernel_description file: +kernel_dependencies_count plugin/plugin-hsa.c /^ unsigned kernel_dependencies_count;$/;" m struct:hsa_kernel_description file: +kernel_dispatch_command_q plugin/plugin-hsa.c /^ hsa_queue_t *kernel_dispatch_command_q;$/;" m struct:agent_info file: +kernel_dispatch_count plugin/plugin-hsa.c /^ uint64_t kernel_dispatch_count;$/;" m struct:GOMP_hsa_kernel_dispatch file: +kernel_info plugin/plugin-hsa.c /^struct kernel_info$/;" s file: +kernel_infos plugin/plugin-hsa.c /^ struct hsa_kernel_description *kernel_infos;$/;" m struct:brig_image_desc typeref:struct:brig_image_desc::hsa_kernel_description file: +kernels plugin/plugin-hsa.c /^ struct kernel_info kernels[];$/;" m struct:module_info typeref:struct:module_info::kernel_info file: +kernels testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^subroutine kernels /;" s +key libgomp.h /^ splay_tree_key key;$/;" m struct:target_var_desc +key splay-tree.h /^ struct splay_tree_key_s key;$/;" m struct:splay_tree_node_s typeref:struct:splay_tree_node_s::splay_tree_key_s +ki testsuite/libgomp.c/loop-13.c /^volatile int ji = 100, ki = 2;$/;" v +ki testsuite/libgomp.c/loop-14.c /^volatile int ji = 100, ki = 2;$/;" v +ki testsuite/libgomp.c/loop-15.c /^volatile int ji = 100, ki = 2;$/;" v +kind libgomp.h /^ enum gomp_task_kind kind;$/;" m struct:gomp_task typeref:enum:gomp_task::gomp_task_kind +kind libgomp.h /^ enum gomp_task_kind kind;$/;" m struct:gomp_tdg_task typeref:enum:gomp_tdg_task::gomp_task_kind +kind testsuite/libgomp.fortran/lib4.f90 /^ integer (omp_sched_kind)/;" v program:lib4 +kinds libgomp.h /^ unsigned short *kinds;$/;" m struct:gomp_target_task +kk testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k, kk,/;" v program:collapse3 +kkk testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k, kk, kkk,/;" v program:collapse3 +kll testsuite/libgomp.c/loop-13.c /^volatile long long int jll = 100, kll = 2;$/;" v +kll testsuite/libgomp.c/loop-14.c /^volatile long long int jll = 100, kll = 2;$/;" v +kll testsuite/libgomp.c/loop-15.c /^volatile long long int jll = 100, kll = 2;$/;" v +ku testsuite/libgomp.c/loop-13.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +ku testsuite/libgomp.c/loop-14.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +ku testsuite/libgomp.c/loop-15.c /^volatile unsigned int ju = 100, ku = 2;$/;" v +kull testsuite/libgomp.c/loop-13.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +kull testsuite/libgomp.c/loop-14.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +kull testsuite/libgomp.c/loop-15.c /^volatile unsigned long long int jull = 100, kull = 2;$/;" v +l priority_queue.h /^ struct priority_list l;$/;" m struct:prio_splay_tree_key_s typeref:struct:prio_splay_tree_key_s::priority_list +l priority_queue.h /^ struct priority_list l;$/;" m struct:priority_queue typeref:struct:priority_queue::priority_list +l testsuite/libgomp.c++/atomic-6.C /^long long l, m;$/;" v +l testsuite/libgomp.c++/atomic-7.C /^long long l, m;$/;" v +l testsuite/libgomp.c++/ctor-12.C /^ int l;$/;" m struct:A file: +l testsuite/libgomp.c++/shared-1.C /^ int l[5][10];$/;" m struct:Y file: +l testsuite/libgomp.c++/task-2.C /^int l = 5;$/;" v +l testsuite/libgomp.c++/task-3.C /^ unsigned long l;$/;" m struct:A file: +l testsuite/libgomp.c++/task-5.C /^ unsigned long l;$/;" m struct:A file: +l testsuite/libgomp.c/atomic-13.c /^long long l, m;$/;" v +l testsuite/libgomp.c/atomic-6.c /^union { unsigned long long l; double d; } u = { .l = 0x7ff0000000072301ULL };$/;" m union:__anon26 file: +l testsuite/libgomp.c/loop-13.c /^unsigned long long l;$/;" v +l testsuite/libgomp.c/loop-14.c /^unsigned long long l;$/;" v +l testsuite/libgomp.c/loop-15.c /^unsigned long long l;$/;" v +l testsuite/libgomp.c/pr26943-3.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +l testsuite/libgomp.c/pr26943-4.c /^int a = 8, b = 12, c = 16, d = 20, j = 0, l = 0;$/;" v +l testsuite/libgomp.c/shared-1.c /^ int l[5][10];$/;" m struct:Y file: +l testsuite/libgomp.c/task-3.c /^int l = 5;$/;" v +l testsuite/libgomp.fortran/allocatable1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable12.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable3.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable4.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable7.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable8.f90 /^ lo/;" v +l testsuite/libgomp.fortran/allocatable9.f90 /^ lo/;" v +l testsuite/libgomp.fortran/associate2.f90 /^ integer :: v(4), i, j, k, l$/;" v program:associate2 +l testsuite/libgomp.fortran/collapse1.f90 /^ lo/;" v program:collapse1 +l testsuite/libgomp.fortran/condinc1.f /^ lo/;" v program:condinc1 +l testsuite/libgomp.fortran/condinc2.f /^ lo/;" v program:condinc2 +l testsuite/libgomp.fortran/condinc3.f90 /^ lo/;" v program:condinc3 +l testsuite/libgomp.fortran/condinc4.f90 /^ lo/;" v program:condinc4 +l testsuite/libgomp.fortran/crayptr1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/crayptr2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/crayptr3.f90 /^ lo/;" v +l testsuite/libgomp.fortran/doacross1.f90 /^ integer :: i, j, k, l,/;" v +l testsuite/libgomp.fortran/doacross2.f90 /^ integer :: j, k, l,/;" v +l testsuite/libgomp.fortran/doacross3.f90 /^ integer :: j, k, l,/;" v +l testsuite/libgomp.fortran/lib1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/lock-1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/lock-2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/pointer2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/pr48894.f90 /^ lo/;" v +l testsuite/libgomp.fortran/reduction2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/sharing1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/sharing2.f90 /^ lo/;" v +l testsuite/libgomp.fortran/simd1.f90 /^ integer :: i, j, k, l,/;" v +l testsuite/libgomp.fortran/threadprivate1.f90 /^ lo/;" v +l testsuite/libgomp.fortran/threadprivate4.f90 /^ lo/;" v +l testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l,/;" v +l testsuite/libgomp.oacc-fortran/collapse-1.f90 /^ lo/;" v program:collapse1 +l testsuite/libgomp.oacc-fortran/collapse-2.f90 /^ lo/;" v program:collapse2 +l testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k, kk, kkk, l,/;" v program:collapse3 +l testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ lo/;" v program:collapse4 +l testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ lo/;" v program:collapse5 +l testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ lo/;" v program:collapse6 +l testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ lo/;" v program:collapse7 +l testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ lo/;" v program:collapse8 +la testsuite/libgomp.fortran/reduction2.f90 /^ logical :: l, la /;" v +last_parent_depends_on priority_queue.h /^ struct priority_node *last_parent_depends_on;$/;" m struct:priority_list typeref:struct:priority_list::priority_node +last_team libgomp.h /^ struct gomp_team *last_team;$/;" m struct:gomp_thread_pool typeref:struct:gomp_thread_pool::gomp_team +last_work_share libgomp.h /^ struct gomp_work_share *last_work_share;$/;" m struct:gomp_team_state typeref:struct:gomp_team_state::gomp_work_share +lastprivate testsuite/libgomp.fortran/lastprivate1.f90 /^program lastprivate$/;" p +lastprivate testsuite/libgomp.fortran/lastprivate2.f90 /^program lastprivate$/;" p +launch plugin/plugin-nvptx.c /^ const struct targ_fn_launch *launch;$/;" m struct:targ_fn_descriptor typeref:struct:targ_fn_descriptor::targ_fn_launch file: +lck testsuite/libgomp.c/appendix-a/a.40.1.c /^ omp_nest_lock_t lck;$/;" m struct:__anon28 file: +lck testsuite/libgomp.fortran/lib1.f90 /^ integer (kind = omp_lock_kind) :: lck$/;" v +ld testsuite/libgomp.c/atomic-2.c /^long double ld = 3;$/;" v +ld testsuite/libgomp.c/pr64868.c /^long double ld = 8.0L;$/;" v +left splay-tree.h /^ splay_tree_node left;$/;" m struct:splay_tree_node_s +len testsuite/libgomp.c/affinity-1.c /^ int start, len;$/;" m struct:place file: +length libgomp.h /^ uintptr_t length;$/;" m struct:target_var_desc +level libgomp.h /^ unsigned level;$/;" m struct:gomp_team_state +lexp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ logical lgot, lexp,/;" v program:main +lexp testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ logical lgot, lexp$/;" v program:main +lgot testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ logical lgot,/;" v program:main +lgot testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^ logical lgot,/;" v program:main +lhs testsuite/libgomp.fortran/pr34020.f90 /^ real lhs,/;" v +lib4 testsuite/libgomp.fortran/lib4.f90 /^program lib4$/;" p +link_key libgomp.h /^ splay_tree_key link_key;$/;" m struct:splay_tree_key_s +link_ptx plugin/plugin-nvptx.c /^link_ptx (CUmodule *module, const struct targ_ptx_obj *ptx_objs,$/;" f file: +list libgomp.h /^ struct target_var_desc list[];$/;" m struct:target_mem_desc typeref:struct:target_mem_desc::target_var_desc +list_count libgomp.h /^ size_t list_count;$/;" m struct:target_mem_desc +ll testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k, kk, kkk, l, ll,/;" v program:collapse3 +lll testsuite/libgomp.oacc-fortran/collapse-3.f90 /^ integer :: a(3,3,3), k, kk, kkk, l, ll, lll$/;" v program:collapse3 +lo testsuite/libgomp.c/sort-1.c /^ int lo;$/;" m struct:int_pair file: +load_image_func libgomp.h /^ __typeof (GOMP_OFFLOAD_load_image) *load_image_func;$/;" m struct:gomp_device_descr +local_g_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_g_1()$/;" f +local_w_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_w_1()$/;" f +local_w_2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_w_2()$/;" f +local_w_3 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_w_3()$/;" f +local_w_4 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_w_4()$/;" f +local_w_5 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void local_w_5()$/;" f +lock config/linux/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon40 +lock config/nvptx/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon36 +lock config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon31 +lock config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; } omp_nest_lock_25_t;$/;" m struct:__anon30 +lock config/posix/omp-lock.h /^typedef struct { sem_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon32 +lock config/posix/ptrlock.h /^typedef struct { void *ptr; gomp_mutex_t lock; } gomp_ptrlock_t;$/;" m struct:__anon34 +lock config/rtems/pool.h /^ pthread_spinlock_t lock;$/;" m struct:gomp_thread_pool_reservoir +lock libgomp.h /^ gomp_mutex_t lock __attribute__((aligned (64)));$/;" m struct:gomp_work_share +lock libgomp.h /^ gomp_mutex_t lock;$/;" m struct:gomp_device_descr +lock testsuite/libgomp.c/lock-3.c /^omp_nest_lock_t lock;$/;" v +lock testsuite/libgomp.fortran/lock-1.f90 /^ integer (kind = omp_nest_lock_/;" v +lock testsuite/libgomp.fortran/lock-2.f90 /^ integer (kind = omp_nest_lock_/;" v +lookup_dev oacc-mem.c /^lookup_dev (struct target_mem_desc *tgt, void *d, size_t s)$/;" f file: +lookup_host oacc-mem.c /^lookup_host (struct gomp_device_descr *dev, void *h, size_t s)$/;" f file: +loop_g_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_1()$/;" f +loop_g_2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_2()$/;" f +loop_g_3 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_3()$/;" f +loop_g_4 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_4()$/;" f +loop_g_5 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_5()$/;" f +loop_g_6 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_g_6()$/;" f +loop_v_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_v_1()$/;" f +loop_v_2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_v_2()$/;" f +loop_w_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_1()$/;" f +loop_w_2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_2()$/;" f +loop_w_3 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_3()$/;" f +loop_w_4 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_4()$/;" f +loop_w_5 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_5()$/;" f +loop_w_6 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_6()$/;" f +loop_w_7 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void loop_w_7()$/;" f +low testsuite/libgomp.hsa.c/switch-branch-1.c 71;" d file: +low testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ integer, parameter :: n = 20, c = 10, low /;" v program:subarrays +lrc testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ logical :: lrg, lrw, lrv, lrc,/;" v program:reduction_1 +lrc testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ logical :: lrg, lrw, lrv, lrc,/;" v program:reduction_2 +lrc testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ logical :: lrg, lrw, lrv, lrc,/;" v program:reduction_3 +lrg testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ logical :: lrg,/;" v program:reduction_1 +lrg testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ logical :: lrg,/;" v program:reduction_2 +lrg testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ logical :: lrg,/;" v program:reduction_3 +lrv testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ logical :: lrg, lrw, lrv,/;" v program:reduction_1 +lrv testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ logical :: lrg, lrw, lrv,/;" v program:reduction_2 +lrv testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ logical :: lrg, lrw, lrv,/;" v program:reduction_3 +lrw testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ logical :: lrg, lrw,/;" v program:reduction_1 +lrw testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ logical :: lrg, lrw,/;" v program:reduction_2 +lrw testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ logical :: lrg, lrw,/;" v program:reduction_3 +ltmp testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^ logical lgot, lexp, ltmp$/;" v program:main +lvresult testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ logical :: lrg, lrw, lrv, lrc, lvresult$/;" v program:reduction_1 +lvresult testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ logical :: lrg, lrw, lrv, lrc, lvresult$/;" v program:reduction_2 +lvresult testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ logical :: lrg, lrw, lrv, lrc, lvresult$/;" v program:reduction_3 +m testsuite/libgomp.c++/atomic-6.C /^long long l, m;$/;" v +m testsuite/libgomp.c++/atomic-7.C /^long long l, m;$/;" v +m testsuite/libgomp.c++/simd-1.C /^int k, m;$/;" v +m testsuite/libgomp.c++/simd-3.C /^int k, m;$/;" v +m testsuite/libgomp.c/atomic-13.c /^long long l, m;$/;" v +m testsuite/libgomp.c/simd-1.c /^int k, m;$/;" v +m testsuite/libgomp.c/simd-3.c /^int k, m;$/;" v +m testsuite/libgomp.c/simd-7.c /^int k, m;$/;" v +m testsuite/libgomp.c/taskloop-2.c /^int u[1024], v[1024], w[1024], m;$/;" v +m testsuite/libgomp.fortran/alloc-comp-1.f90 /^mo/;" m +m testsuite/libgomp.fortran/alloc-comp-2.f90 /^mo/;" m +m testsuite/libgomp.fortran/alloc-comp-3.f90 /^mo/;" m +m testsuite/libgomp.fortran/doacross1.f90 /^ integer :: i, j, k, l, m$/;" v +m testsuite/libgomp.fortran/doacross2.f90 /^ integer :: j, k, l, m$/;" v +m testsuite/libgomp.fortran/doacross3.f90 /^ integer :: j, k, l, m$/;" v +m testsuite/libgomp.fortran/jacobi.f /^ integer n,m,/;" v program:main +m testsuite/libgomp.fortran/pr27395-1.f90 /^ integer, parame/;" v program:pr27395_1 +m testsuite/libgomp.fortran/pr27395-2.f90 /^ integer, parame/;" v program:pr27395_2 +m testsuite/libgomp.fortran/reduction2.f90 /^ logical :: l, la (4), m,/;" v +m testsuite/libgomp.fortran/sharing2.f90 /^ integer :: i, j, k, m,/;" v +m testsuite/libgomp.fortran/simd2.f90 /^ integer :: a(1024), b(1024), k, m,/;" v +m testsuite/libgomp.fortran/simd3.f90 /^ integer :: a(1024), b(1024), k, m,/;" v +m testsuite/libgomp.fortran/simd4.f90 /^ integer :: a(1024), b(1024), k, m,/;" v +m testsuite/libgomp.fortran/simd7.f90 /^ integer, allocatable :: g(:), m$/;" v +m testsuite/libgomp.fortran/taskloop2.f90 /^ integer, save :: u(1024), v(1024), w(1024), m$/;" v +m testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m,/;" v +m testsuite/libgomp.fortran/udr5.f90 /^mo/;" m +m testsuite/libgomp.fortran/udr6.f90 /^mo/;" m +m1 testsuite/libgomp.c++/member-1.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.c++/member-2.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.c++/member-3.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.c++/member-4.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.c++/member-5.C /^A::m1 (const I &x, const I &y)$/;" f class:A +m1 testsuite/libgomp.c++/member-6.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.c++/member-7.C /^A::m1 ()$/;" f class:A +m1 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1,/;" v +m1 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1,/;" v +m1 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1,/;" v +m1 testsuite/libgomp.fortran/pr66680.f90 /^module m1 /;" m +m1 testsuite/libgomp.oacc-fortran/routine-2.f90 /^ module m1$/;" m +m10 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10,/;" v +m10 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10,/;" v +m10 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10,/;" v +m11 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11,/;" v +m11 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11,/;" v +m11 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11,/;" v +m12 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11, m12,/;" v +m12 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11, m12,/;" v +m12 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11, m12,/;" v +m13 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11, m12, m13,/;" v +m13 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11, m12, m13,/;" v +m13 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11, m12, m13,/;" v +m14 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11, m12, m13, m14,/;" v +m14 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11, m12, m13, m14,/;" v +m14 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11, m12, m13, m14,/;" v +m15 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15,/;" v +m15 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15,/;" v +m15 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15,/;" v +m16 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15, m16$/;" v +m16 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15, m16$/;" v +m16 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9, m10, m11, m12, m13, m14, m15, m16$/;" v +m2 testsuite/libgomp.c++/member-5.C /^B::m2 (const Q &u, const Q &v, const I &x, const I &y)$/;" f class:B +m2 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2,/;" v +m2 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2,/;" v +m2 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2,/;" v +m2 testsuite/libgomp.fortran/pr66680.f90 /^module m2$/;" m +m3 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3,/;" v +m3 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3,/;" v +m3 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3,/;" v +m4 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3, m4,/;" v +m4 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3, m4,/;" v +m4 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3, m4,/;" v +m5 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3, m4, m5,/;" v +m5 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3, m4, m5,/;" v +m5 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3, m4, m5,/;" v +m6 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3, m4, m5, m6,/;" v +m6 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3, m4, m5, m6,/;" v +m6 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3, m4, m5, m6,/;" v +m7 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7,/;" v +m7 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7,/;" v +m7 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7,/;" v +m8 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7, m8$/;" v +m8 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7, m8$/;" v +m8 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m1, m2, m3, m4, m5, m6, m7, m8$/;" v +m9 testsuite/libgomp.fortran/doacross1.f90 /^ integer :: m9,/;" v +m9 testsuite/libgomp.fortran/doacross2.f90 /^ integer :: m9,/;" v +m9 testsuite/libgomp.fortran/doacross3.f90 /^ integer :: m9,/;" v +ma testsuite/libgomp.fortran/reduction2.f90 /^ logical :: l, la (4), m, ma /;" v +main testsuite/libgomp.c++/atomic-1.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-10.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-11.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-12.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-13.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-14.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-15.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-2.C /^main (void)$/;" f +main testsuite/libgomp.c++/atomic-3.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-4.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-5.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-6.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-7.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-8.C /^main ()$/;" f +main testsuite/libgomp.c++/atomic-9.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-for-1.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-for-2.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-parallel-1.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-parallel-2.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-parallel-3.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-sections-1.C /^main ()$/;" f +main testsuite/libgomp.c++/cancel-taskgroup-3.C /^main ()$/;" f +main testsuite/libgomp.c++/collapse-1.C /^main ()$/;" f +main testsuite/libgomp.c++/collapse-2.C /^main ()$/;" f +main testsuite/libgomp.c++/copyin-1.C /^main (void)$/;" f +main testsuite/libgomp.c++/copyin-2.C /^main (void)$/;" f +main testsuite/libgomp.c++/ctor-1.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-10.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-11.C /^main ()$/;" f +main testsuite/libgomp.c++/ctor-12.C /^main ()$/;" f +main testsuite/libgomp.c++/ctor-13.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-2.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-3.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-4.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-5.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-6.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-7.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-8.C /^int main()$/;" f +main testsuite/libgomp.c++/ctor-9.C /^int main()$/;" f +main testsuite/libgomp.c++/declare_target-1.C /^int main ()$/;" f +main testsuite/libgomp.c++/doacross-1.C /^main ()$/;" f +main testsuite/libgomp.c++/examples-4/declare_target-2.C /^int main ()$/;" f +main testsuite/libgomp.c++/examples-4/target_data-5.C /^int main ()$/;" f +main testsuite/libgomp.c++/for-1.C /^main ()$/;" f +main testsuite/libgomp.c++/for-10.C /^main ()$/;" f +main testsuite/libgomp.c++/for-11.C /^main ()$/;" f +main testsuite/libgomp.c++/for-12.C /^main ()$/;" f +main testsuite/libgomp.c++/for-13.C /^main ()$/;" f +main testsuite/libgomp.c++/for-14.C /^main ()$/;" f +main testsuite/libgomp.c++/for-2.C /^main ()$/;" f +main testsuite/libgomp.c++/for-3.C /^main ()$/;" f +main testsuite/libgomp.c++/for-4.C /^main ()$/;" f +main testsuite/libgomp.c++/for-5.C /^main ()$/;" f +main testsuite/libgomp.c++/for-6.C /^main ()$/;" f +main testsuite/libgomp.c++/for-7.C /^main ()$/;" f +main testsuite/libgomp.c++/for-8.C /^main ()$/;" f +main testsuite/libgomp.c++/for-9.C /^main ()$/;" f +main testsuite/libgomp.c++/linear-1.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-1.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-10.C /^main (void)$/;" f +main testsuite/libgomp.c++/loop-11.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-12.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-2.C /^main()$/;" f +main testsuite/libgomp.c++/loop-3.C /^main (void)$/;" f +main testsuite/libgomp.c++/loop-4.C /^main()$/;" f +main testsuite/libgomp.c++/loop-5.C /^int main()$/;" f +main testsuite/libgomp.c++/loop-6.C /^int main()$/;" f +main testsuite/libgomp.c++/loop-7.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-8.C /^main ()$/;" f +main testsuite/libgomp.c++/loop-9.C /^main ()$/;" f +main testsuite/libgomp.c++/master-1.C /^main ()$/;" f +main testsuite/libgomp.c++/member-1.C /^main ()$/;" f +main testsuite/libgomp.c++/member-2.C /^main ()$/;" f +main testsuite/libgomp.c++/member-3.C /^main ()$/;" f +main testsuite/libgomp.c++/member-4.C /^main ()$/;" f +main testsuite/libgomp.c++/member-5.C /^main ()$/;" f +main testsuite/libgomp.c++/member-6.C /^main ()$/;" f +main testsuite/libgomp.c++/member-7.C /^main ()$/;" f +main testsuite/libgomp.c++/nested-1.C /^int main()$/;" f +main testsuite/libgomp.c++/parallel-1.C /^main ()$/;" f +main testsuite/libgomp.c++/pr24455.C /^int main()$/;" f +main testsuite/libgomp.c++/pr26691.C /^main ()$/;" f +main testsuite/libgomp.c++/pr26943.C /^main ()$/;" f +main testsuite/libgomp.c++/pr27337.C /^main (void)$/;" f +main testsuite/libgomp.c++/pr30703.C /^main ()$/;" f +main testsuite/libgomp.c++/pr34513.C /^main ()$/;" f +main testsuite/libgomp.c++/pr35185.C /^main ()$/;" f +main testsuite/libgomp.c++/pr38650.C /^main ()$/;" f +main testsuite/libgomp.c++/pr39573.C /^main ()$/;" f +main testsuite/libgomp.c++/pr43893.C /^main ()$/;" f +main testsuite/libgomp.c++/pr48869.C /^main ()$/;" f +main testsuite/libgomp.c++/pr49043.C /^main ()$/;" f +main testsuite/libgomp.c++/pr56217.C /^main ()$/;" f +main testsuite/libgomp.c++/pr58706.C /^main ()$/;" f +main testsuite/libgomp.c++/pr63248.C /^main ()$/;" f +main testsuite/libgomp.c++/pr66702-1.C /^main ()$/;" f +main testsuite/libgomp.c++/pr66702-2.C /^main ()$/;" f +main testsuite/libgomp.c++/pr69393.C /^main ()$/;" f +main testsuite/libgomp.c++/pr69555-1.C /^main ()$/;" f +main testsuite/libgomp.c++/pr69555-2.C /^main ()$/;" f +main testsuite/libgomp.c++/pr70376.C /^main ()$/;" f +main testsuite/libgomp.c++/pr81130.C /^main ()$/;" f +main testsuite/libgomp.c++/pr81314.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-1.C /^main (void)$/;" f +main testsuite/libgomp.c++/reduction-10.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-11.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-12.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-2.C /^main (void)$/;" f +main testsuite/libgomp.c++/reduction-3.C /^main (void)$/;" f +main testsuite/libgomp.c++/reduction-4.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-5.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-6.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-7.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-8.C /^main ()$/;" f +main testsuite/libgomp.c++/reduction-9.C /^main ()$/;" f +main testsuite/libgomp.c++/reference-1.C /^main ()$/;" f +main testsuite/libgomp.c++/sections-1.C /^int main (int argc, char *argv[]) {$/;" f +main testsuite/libgomp.c++/shared-1.C /^main()$/;" f +main testsuite/libgomp.c++/shared-2.C /^int main()$/;" f +main testsuite/libgomp.c++/simd-1.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-2.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-3.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-4.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-5.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-6.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-7.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-8.C /^main ()$/;" f +main testsuite/libgomp.c++/simd-9.C /^main ()$/;" f +main testsuite/libgomp.c++/simd14.C /^main ()$/;" f +main testsuite/libgomp.c++/single-1.C /^main()$/;" f +main testsuite/libgomp.c++/single-2.C /^main()$/;" f +main testsuite/libgomp.c++/single-3.C /^int main()$/;" f +main testsuite/libgomp.c++/target-10.C /^main ()$/;" f +main testsuite/libgomp.c++/target-11.C /^main ()$/;" f +main testsuite/libgomp.c++/target-12.C /^main ()$/;" f +main testsuite/libgomp.c++/target-13.C /^main ()$/;" f +main testsuite/libgomp.c++/target-14.C /^main ()$/;" f +main testsuite/libgomp.c++/target-15.C /^main ()$/;" f +main testsuite/libgomp.c++/target-16.C /^main ()$/;" f +main testsuite/libgomp.c++/target-17.C /^main ()$/;" f +main testsuite/libgomp.c++/target-18.C /^main ()$/;" f +main testsuite/libgomp.c++/target-19.C /^main ()$/;" f +main testsuite/libgomp.c++/target-2.C /^main ()$/;" f +main testsuite/libgomp.c++/target-20.C /^main ()$/;" f +main testsuite/libgomp.c++/target-21.C /^main ()$/;" f +main testsuite/libgomp.c++/target-6.C /^main ()$/;" f +main testsuite/libgomp.c++/target-7.C /^main ()$/;" f +main testsuite/libgomp.c++/target-8.C /^main ()$/;" f +main testsuite/libgomp.c++/target-9.C /^main ()$/;" f +main testsuite/libgomp.c++/task-1.C /^main ()$/;" f +main testsuite/libgomp.c++/task-2.C /^main (void)$/;" f +main testsuite/libgomp.c++/task-3.C /^main ()$/;" f +main testsuite/libgomp.c++/task-4.C /^main ()$/;" f +main testsuite/libgomp.c++/task-5.C /^main ()$/;" f +main testsuite/libgomp.c++/task-6.C /^main ()$/;" f +main testsuite/libgomp.c++/task-7.C /^int main()$/;" f +main testsuite/libgomp.c++/task-8.C /^main ()$/;" f +main testsuite/libgomp.c++/taskloop-5.C /^main ()$/;" f +main testsuite/libgomp.c++/taskloop-6.C /^main ()$/;" f +main testsuite/libgomp.c++/taskloop-7.C /^main ()$/;" f +main testsuite/libgomp.c++/taskloop-8.C /^main ()$/;" f +main testsuite/libgomp.c++/taskloop-9.C /^main ()$/;" f +main testsuite/libgomp.c++/tls-init1.C /^int main()$/;" f +main testsuite/libgomp.c++/udr-1.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-2.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-3.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-4.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-5.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-6.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-7.C /^main ()$/;" f +main testsuite/libgomp.c++/udr-8.C /^main ()$/;" f +main testsuite/libgomp.c/affinity-1.c /^main ()$/;" f +main testsuite/libgomp.c/affinity-2.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.15.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.16.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.18.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.19.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.2.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.21.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.26.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.29.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.3.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.36.1.c /^int main()$/;" f +main testsuite/libgomp.c/appendix-a/a.39.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.4.1.c /^main ()$/;" f +main testsuite/libgomp.c/appendix-a/a.5.1.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-1.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-10.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-11.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-12.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-13.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-14.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-15.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-16.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-17.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-18.c /^main ()$/;" f +main testsuite/libgomp.c/atomic-2.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-3.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-4.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-5.c /^main (void)$/;" f +main testsuite/libgomp.c/atomic-6.c /^main (void)$/;" f +main testsuite/libgomp.c/autopar-1.c /^main (void)$/;" f +main testsuite/libgomp.c/barrier-1.c /^int main()$/;" f +main testsuite/libgomp.c/cancel-for-1.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-for-2.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-parallel-1.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-parallel-2.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-parallel-3.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-sections-1.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-taskgroup-1.c /^main ()$/;" f +main testsuite/libgomp.c/cancel-taskgroup-2.c /^main ()$/;" f +main testsuite/libgomp.c/collapse-1.c /^main (void)$/;" f +main testsuite/libgomp.c/collapse-2.c /^main (void)$/;" f +main testsuite/libgomp.c/collapse-3.c /^main (void)$/;" f +main testsuite/libgomp.c/copyin-1.c /^main (void)$/;" f +main testsuite/libgomp.c/copyin-2.c /^main (void)$/;" f +main testsuite/libgomp.c/copyin-3.c /^main (void)$/;" f +main testsuite/libgomp.c/critical-1.c /^int main()$/;" f +main testsuite/libgomp.c/critical-2.c /^int main()$/;" f +main testsuite/libgomp.c/debug-1.c /^main (void)$/;" f +main testsuite/libgomp.c/depend-1.c /^main ()$/;" f +main testsuite/libgomp.c/depend-2.c /^main ()$/;" f +main testsuite/libgomp.c/depend-3.c /^main ()$/;" f +main testsuite/libgomp.c/depend-4.c /^main ()$/;" f +main testsuite/libgomp.c/depend-5.c /^main ()$/;" f +main testsuite/libgomp.c/doacross-1.c /^main ()$/;" f +main testsuite/libgomp.c/doacross-2.c /^main ()$/;" f +main testsuite/libgomp.c/doacross-3.c /^main ()$/;" f +main testsuite/libgomp.c/examples-4/array_sections-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/array_sections-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/async_target-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/async_target-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/declare_target-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/declare_target-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/declare_target-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/declare_target-5.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/device-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/device-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/device-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-5.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-6.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/simd-7.c /^int main(void)$/;" f +main testsuite/libgomp.c/examples-4/simd-8.c /^int main(void)$/;" f +main testsuite/libgomp.c/examples-4/target-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target-5.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-6.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_data-7.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_update-1.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/target_update-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/task_dep-1.c /^int main()$/;" f +main testsuite/libgomp.c/examples-4/task_dep-2.c /^int main()$/;" f +main testsuite/libgomp.c/examples-4/task_dep-3.c /^int main()$/;" f +main testsuite/libgomp.c/examples-4/task_dep-4.c /^int main()$/;" f +main testsuite/libgomp.c/examples-4/task_dep-5.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/teams-2.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/teams-3.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/teams-4.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/teams-5.c /^int main ()$/;" f +main testsuite/libgomp.c/examples-4/teams-6.c /^int main ()$/;" f +main testsuite/libgomp.c/for-1.c /^main ()$/;" f +main testsuite/libgomp.c/for-2.c /^main ()$/;" f +main testsuite/libgomp.c/for-3.c /^main ()$/;" f +main testsuite/libgomp.c/for-4.c /^main ()$/;" f +main testsuite/libgomp.c/for-5.c /^main ()$/;" f +main testsuite/libgomp.c/for-6.c /^main ()$/;" f +main testsuite/libgomp.c/icv-1.c /^main (void)$/;" f +main testsuite/libgomp.c/icv-2.c /^main (void)$/;" f +main testsuite/libgomp.c/lib-1.c /^main (void)$/;" f +main testsuite/libgomp.c/lib-2.c /^main (void)$/;" f +main testsuite/libgomp.c/linear-1.c /^main ()$/;" f +main testsuite/libgomp.c/lock-1.c /^main (void)$/;" f +main testsuite/libgomp.c/lock-2.c /^main (void)$/;" f +main testsuite/libgomp.c/lock-3.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-1.c /^int main()$/;" f +main testsuite/libgomp.c/loop-10.c /^int main (void)$/;" f +main testsuite/libgomp.c/loop-11.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-12.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-13.c /^main ()$/;" f +main testsuite/libgomp.c/loop-14.c /^main ()$/;" f +main testsuite/libgomp.c/loop-15.c /^main ()$/;" f +main testsuite/libgomp.c/loop-16.c /^main ()$/;" f +main testsuite/libgomp.c/loop-2.c /^int main()$/;" f +main testsuite/libgomp.c/loop-3.c /^int main()$/;" f +main testsuite/libgomp.c/loop-4.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-5.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-6.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-7.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-8.c /^main (void)$/;" f +main testsuite/libgomp.c/loop-9.c /^main (void)$/;" f +main testsuite/libgomp.c/monotonic-1.c /^main ()$/;" f +main testsuite/libgomp.c/nested-1.c /^main (void)$/;" f +main testsuite/libgomp.c/nested-2.c /^main (void)$/;" f +main testsuite/libgomp.c/nested-3.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-1.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-2.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-3.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-4.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-5.c /^main (void)$/;" f +main testsuite/libgomp.c/nestedfn-6.c /^main (void)$/;" f +main testsuite/libgomp.c/nonmonotonic-1.c /^main ()$/;" f +main testsuite/libgomp.c/nqueens-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.c/omp-loop01.c /^main ()$/;" f +main testsuite/libgomp.c/omp-loop02.c /^main()$/;" f +main testsuite/libgomp.c/omp-loop03.c /^main (void)$/;" f +main testsuite/libgomp.c/omp-nested-1.c /^int main()$/;" f +main testsuite/libgomp.c/omp-parallel-for.c /^main()$/;" f +main testsuite/libgomp.c/omp-parallel-if.c /^main ()$/;" f +main testsuite/libgomp.c/omp-single-1.c /^main()$/;" f +main testsuite/libgomp.c/omp-single-2.c /^main()$/;" f +main testsuite/libgomp.c/omp-single-3.c /^int main()$/;" f +main testsuite/libgomp.c/omp_hello.c /^int main (int argc, char *argv[]) {$/;" f +main testsuite/libgomp.c/omp_matvec.c /^main ()$/;" f +main testsuite/libgomp.c/omp_orphan.c /^int main (int argc, char *argv[]) $/;" f +main testsuite/libgomp.c/omp_reduction.c /^int main (int argc, char *argv[]) {$/;" f +main testsuite/libgomp.c/omp_workshare1.c /^int main (int argc, char *argv[]) {$/;" f +main testsuite/libgomp.c/omp_workshare2.c /^int main (int argc, char *argv[]) {$/;" f +main testsuite/libgomp.c/omp_workshare3.c /^main () {$/;" f +main testsuite/libgomp.c/omp_workshare4.c /^main () {$/;" f +main testsuite/libgomp.c/ordered-1.c /^int main()$/;" f +main testsuite/libgomp.c/ordered-2.c /^int main()$/;" f +main testsuite/libgomp.c/ordered-3.c /^main (void)$/;" f +main testsuite/libgomp.c/ordered-4.c /^main ()$/;" f +main testsuite/libgomp.c/ordered-5.c /^main ()$/;" f +main testsuite/libgomp.c/parallel-1.c /^int main()$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-2.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-3.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-4.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-5.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-6.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt-7.c /^main (void)$/;" f +main testsuite/libgomp.c/parloops-exit-first-loop-alt.c /^main (void)$/;" f +main testsuite/libgomp.c/pr24455.c /^int main()$/;" f +main testsuite/libgomp.c/pr26171.c /^main ()$/;" f +main testsuite/libgomp.c/pr26943-1.c /^main (void)$/;" f +main testsuite/libgomp.c/pr26943-2.c /^main (void)$/;" f +main testsuite/libgomp.c/pr26943-3.c /^main (void)$/;" f +main testsuite/libgomp.c/pr26943-4.c /^main (void)$/;" f +main testsuite/libgomp.c/pr29947-1.c /^main (void)$/;" f +main testsuite/libgomp.c/pr29947-2.c /^main (void)$/;" f +main testsuite/libgomp.c/pr30494.c /^main (void)$/;" f +main testsuite/libgomp.c/pr32362-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr32362-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr32362-3.c /^main ()$/;" f +main testsuite/libgomp.c/pr32468.c /^main (void)$/;" f +main testsuite/libgomp.c/pr33880.c /^main (void)$/;" f +main testsuite/libgomp.c/pr34513.c /^main ()$/;" f +main testsuite/libgomp.c/pr35130.c /^main (void)$/;" f +main testsuite/libgomp.c/pr35196.c /^main (void)$/;" f +main testsuite/libgomp.c/pr35549.c /^main (void)$/;" f +main testsuite/libgomp.c/pr35625.c /^main (void)$/;" f +main testsuite/libgomp.c/pr36802-1.c /^main (void)$/;" f +main testsuite/libgomp.c/pr36802-2.c /^main (void)$/;" f +main testsuite/libgomp.c/pr36802-3.c /^main (void)$/;" f +main testsuite/libgomp.c/pr38650.c /^main ()$/;" f +main testsuite/libgomp.c/pr39154.c /^main (void)$/;" f +main testsuite/libgomp.c/pr39591-1.c /^main (void)$/;" f +main testsuite/libgomp.c/pr39591-2.c /^main (void)$/;" f +main testsuite/libgomp.c/pr39591-3.c /^main (void)$/;" f +main testsuite/libgomp.c/pr42029.c /^main ()$/;" f +main testsuite/libgomp.c/pr42942.c /^main (void)$/;" f +main testsuite/libgomp.c/pr43893.c /^main ()$/;" f +main testsuite/libgomp.c/pr45784.c /^main ()$/;" f +main testsuite/libgomp.c/pr46032.c /^main (void)$/;" f +main testsuite/libgomp.c/pr46193.c /^main (void)$/;" f +main testsuite/libgomp.c/pr46886.c /^int main ()$/;" f +main testsuite/libgomp.c/pr48591.c /^main ()$/;" f +main testsuite/libgomp.c/pr49897-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr49897-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr49898-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr49898-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr52547.c /^main ()$/;" f +main testsuite/libgomp.c/pr58392.c /^main ()$/;" f +main testsuite/libgomp.c/pr58756.c /^main ()$/;" f +main testsuite/libgomp.c/pr61200.c /^main ()$/;" f +main testsuite/libgomp.c/pr64734.c /^main ()$/;" f +main testsuite/libgomp.c/pr64824.c /^main ()$/;" f +main testsuite/libgomp.c/pr64868.c /^main ()$/;" f +main testsuite/libgomp.c/pr66133.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-3.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-4.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-5.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-6.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-7.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-8.c /^main ()$/;" f +main testsuite/libgomp.c/pr66199-9.c /^main ()$/;" f +main testsuite/libgomp.c/pr68960.c /^main ()$/;" f +main testsuite/libgomp.c/pr69110.c /^main (void)$/;" f +main testsuite/libgomp.c/pr69805.c /^main ()$/;" f +main testsuite/libgomp.c/pr70680-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr70680-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr79940.c /^main ()$/;" f +main testsuite/libgomp.c/pr80394.c /^main ()$/;" f +main testsuite/libgomp.c/pr80809-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr80809-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr80809-3.c /^main ()$/;" f +main testsuite/libgomp.c/pr80853.c /^main ()$/;" f +main testsuite/libgomp.c/pr81687-1.c /^main ()$/;" f +main testsuite/libgomp.c/pr81687-2.c /^main ()$/;" f +main testsuite/libgomp.c/pr81875.c /^main ()$/;" f +main testsuite/libgomp.c/priority.c /^int main()$/;" f +main testsuite/libgomp.c/private-1.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-1.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-10.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-11.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-12.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-13.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-14.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-15.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-2.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-3.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-4.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-5.c /^main (void)$/;" f +main testsuite/libgomp.c/reduction-6.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-7.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-8.c /^main ()$/;" f +main testsuite/libgomp.c/reduction-9.c /^main ()$/;" f +main testsuite/libgomp.c/sections-1.c /^int main()$/;" f +main testsuite/libgomp.c/sections-2.c /^main ()$/;" f +main testsuite/libgomp.c/shared-1.c /^main()$/;" f +main testsuite/libgomp.c/shared-2.c /^int main()$/;" f +main testsuite/libgomp.c/shared-3.c /^int main()$/;" f +main testsuite/libgomp.c/simd-1.c /^main ()$/;" f +main testsuite/libgomp.c/simd-10.c /^main ()$/;" f +main testsuite/libgomp.c/simd-11.c /^main ()$/;" f +main testsuite/libgomp.c/simd-12.c /^main ()$/;" f +main testsuite/libgomp.c/simd-13.c /^main ()$/;" f +main testsuite/libgomp.c/simd-14.c /^main ()$/;" f +main testsuite/libgomp.c/simd-15.c /^main ()$/;" f +main testsuite/libgomp.c/simd-16.c /^main ()$/;" f +main testsuite/libgomp.c/simd-17.c /^main ()$/;" f +main testsuite/libgomp.c/simd-2.c /^main ()$/;" f +main testsuite/libgomp.c/simd-3.c /^main ()$/;" f +main testsuite/libgomp.c/simd-4.c /^main ()$/;" f +main testsuite/libgomp.c/simd-5.c /^main ()$/;" f +main testsuite/libgomp.c/simd-6.c /^main ()$/;" f +main testsuite/libgomp.c/simd-7.c /^main ()$/;" f +main testsuite/libgomp.c/simd-8.c /^main ()$/;" f +main testsuite/libgomp.c/simd-9.c /^main ()$/;" f +main testsuite/libgomp.c/single-1.c /^int main()$/;" f +main testsuite/libgomp.c/single-2.c /^main (void)$/;" f +main testsuite/libgomp.c/sort-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.c/static-chunk-size-one.c /^main (void)$/;" f +main testsuite/libgomp.c/target-1.c /^main ()$/;" f +main testsuite/libgomp.c/target-10.c /^main ()$/;" f +main testsuite/libgomp.c/target-11.c /^int main ()$/;" f +main testsuite/libgomp.c/target-12.c /^main ()$/;" f +main testsuite/libgomp.c/target-13.c /^main ()$/;" f +main testsuite/libgomp.c/target-14.c /^main ()$/;" f +main testsuite/libgomp.c/target-15.c /^main ()$/;" f +main testsuite/libgomp.c/target-16.c /^main ()$/;" f +main testsuite/libgomp.c/target-17.c /^main ()$/;" f +main testsuite/libgomp.c/target-18.c /^main ()$/;" f +main testsuite/libgomp.c/target-19.c /^main ()$/;" f +main testsuite/libgomp.c/target-2.c /^main ()$/;" f +main testsuite/libgomp.c/target-20.c /^int main ()$/;" f +main testsuite/libgomp.c/target-21.c /^main ()$/;" f +main testsuite/libgomp.c/target-22.c /^main ()$/;" f +main testsuite/libgomp.c/target-23.c /^main ()$/;" f +main testsuite/libgomp.c/target-24.c /^main ()$/;" f +main testsuite/libgomp.c/target-25.c /^main ()$/;" f +main testsuite/libgomp.c/target-26.c /^main ()$/;" f +main testsuite/libgomp.c/target-27.c /^main ()$/;" f +main testsuite/libgomp.c/target-28.c /^main ()$/;" f +main testsuite/libgomp.c/target-29.c /^main ()$/;" f +main testsuite/libgomp.c/target-3.c /^main ()$/;" f +main testsuite/libgomp.c/target-30.c /^main ()$/;" f +main testsuite/libgomp.c/target-31.c /^main ()$/;" f +main testsuite/libgomp.c/target-32.c /^int main ()$/;" f +main testsuite/libgomp.c/target-33.c /^main ()$/;" f +main testsuite/libgomp.c/target-34.c /^main ()$/;" f +main testsuite/libgomp.c/target-35.c /^main ()$/;" f +main testsuite/libgomp.c/target-36.c /^main ()$/;" f +main testsuite/libgomp.c/target-4.c /^main ()$/;" f +main testsuite/libgomp.c/target-5.c /^main ()$/;" f +main testsuite/libgomp.c/target-6.c /^main ()$/;" f +main testsuite/libgomp.c/target-7.c /^main ()$/;" f +main testsuite/libgomp.c/target-8.c /^main ()$/;" f +main testsuite/libgomp.c/target-9.c /^main ()$/;" f +main testsuite/libgomp.c/target-critical-1.c /^int main ()$/;" f +main testsuite/libgomp.c/target-link-1.c /^main ()$/;" f +main testsuite/libgomp.c/target-teams-1.c /^main ()$/;" f +main testsuite/libgomp.c/task-1.c /^main (void)$/;" f +main testsuite/libgomp.c/task-2.c /^main (void)$/;" f +main testsuite/libgomp.c/task-3.c /^main (void)$/;" f +main testsuite/libgomp.c/task-4.c /^main (void)$/;" f +main testsuite/libgomp.c/task-5.c /^main ()$/;" f +main testsuite/libgomp.c/taskgroup-1.c /^main ()$/;" f +main testsuite/libgomp.c/taskloop-1.c /^main ()$/;" f +main testsuite/libgomp.c/taskloop-2.c /^main ()$/;" f +main testsuite/libgomp.c/taskloop-3.c /^main ()$/;" f +main testsuite/libgomp.c/taskloop-4.c /^main ()$/;" f +main testsuite/libgomp.c/thread-limit-1.c /^main ()$/;" f +main testsuite/libgomp.c/thread-limit-2.c /^main ()$/;" f +main testsuite/libgomp.c/thread-limit-3.c /^main ()$/;" f +main testsuite/libgomp.c/udr-1.c /^main ()$/;" f +main testsuite/libgomp.c/udr-2.c /^main ()$/;" f +main testsuite/libgomp.c/udr-3.c /^main ()$/;" f +main testsuite/libgomp.c/uns-outer-4.c /^main (void)$/;" f +main testsuite/libgomp.c/vla-1.c /^main (int argc, char **argv[])$/;" f +main testsuite/libgomp.fortran/examples-4/simd-2.f90 /^program main$/;" p +main testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^program main$/;" p +main testsuite/libgomp.fortran/jacobi.f /^ program main /;" p +main testsuite/libgomp.fortran/openmp_version-1.f /^ program main$/;" p +main testsuite/libgomp.fortran/openmp_version-2.f90 /^program main$/;" p +main testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^program main$/;" p +main testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^program main$/;" p +main testsuite/libgomp.fortran/pr66680.f90 /^program main$/;" p +main testsuite/libgomp.graphite/force-parallel-1.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-2.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-3.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-4.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-5.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-6.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-7.c /^int main (void)$/;" f +main testsuite/libgomp.graphite/force-parallel-8.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/force-parallel-9.c /^int main(void)$/;" f +main testsuite/libgomp.graphite/pr41118.c /^int main(void)$/;" f +main testsuite/libgomp.hsa.c/alloca-1.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/bitfield-1.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/bits-insns.c /^int main()$/;" f +main testsuite/libgomp.hsa.c/builtins-1.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/complex-1.c /^main (void)$/;" f +main testsuite/libgomp.hsa.c/complex-align-2.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/formal-actual-args-1.c /^main (int argc)$/;" f +main testsuite/libgomp.hsa.c/function-call-1.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/get-level-1.c /^main ()$/;" f +main testsuite/libgomp.hsa.c/gridify-1.c /^int main (int argc, char **argv)$/;" f +main testsuite/libgomp.hsa.c/gridify-2.c /^int main (int argc, char **argv)$/;" f +main testsuite/libgomp.hsa.c/gridify-3.c /^int main (int argc, char **argv)$/;" f +main testsuite/libgomp.hsa.c/gridify-4.c /^int main (int argc, char **argv)$/;" f +main testsuite/libgomp.hsa.c/memory-operations-1.c /^main (void)$/;" f +main testsuite/libgomp.hsa.c/pr69568.c /^int main (int argc, char **argv)$/;" f +main testsuite/libgomp.hsa.c/rotate-1.c /^main (int argc)$/;" f +main testsuite/libgomp.hsa.c/switch-1.c /^main (int argc)$/;" f +main testsuite/libgomp.hsa.c/switch-branch-1.c /^main (int argc)$/;" f +main testsuite/libgomp.hsa.c/switch-sbr-2.c /^int main(int argc)$/;" f +main testsuite/libgomp.hsa.c/tiling-1.c /^int main(int argc, char* argv[]){$/;" f +main testsuite/libgomp.hsa.c/tiling-2.c /^int main(int argc, char* argv[]){$/;" f +main testsuite/libgomp.oacc-c++/declare-1.C /^main (void)$/;" f +main testsuite/libgomp.oacc-c++/template-reduction.C /^main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/abort-1.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/abort-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/abort-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/abort-4.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/abort-5.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/acc-on-device-2.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/acc_on_device-1.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/asyncwait-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/atomic_capture-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/atomic_capture-2.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/atomic_rw-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/atomic_update-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/clauses-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/clauses-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/collapse-1.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/collapse-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/collapse-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/collapse-4.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/combined-directives-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/combined-reduction.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/context-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/context-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/context-3.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/context-4.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/crash-1.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-1.c /^int main(void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-2-lib.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-3.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-1.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-2.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-3.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-4.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-5.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-6.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-7.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-already-8.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/data-clauses.h /^int main(void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/declare-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/declare-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/declare-4.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/declare-5.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/declare-vla.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/default-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/deviceptr-1.c /^int main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/enter_exit-lib.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c /^main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/gang-static-1.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/gang-static-2.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/host_data-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/host_data-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/host_data-4.c /^int main (int argc, char* argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/host_data-5.c /^int main (int argc, char* argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/if-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-empty.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-4.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-5.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-6.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-clauses.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-collapse.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-mod-not-zero.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-n.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop-nest.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-loop.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/kernels-reduction.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-10.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-11.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-12.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-13.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-14.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-15.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-16.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-17.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-18.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-19.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-20.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-21.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-22.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-23.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-24.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-25.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-26.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-27.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-28.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-29.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-3.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-30.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-31.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-32.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-33.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-34.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-35.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-36.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-37.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-38.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-39.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-4.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-40.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-41.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-42.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-43.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-44.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-45.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-46.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-47.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-48.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-49.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-5.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-50.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-51.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-52.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-53.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-54.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-55.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-56.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-57.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-58.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-59.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-6.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-60.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-61.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-62.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-63.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-64.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-65.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-66.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-67.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-68.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-69.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-7.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-70.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-71.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-72.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-73.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-74.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-75.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-76.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-77.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-78.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-79.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-8.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-80.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-81.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-82.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-83.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-84.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-85.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-86.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-87.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-88.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-89.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-9.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-90.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-91.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/lib-92.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-g-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-g-2.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-gwv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-g-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-gwv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-v-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-v-2.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-w-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-w-2.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-red-wv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-v-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-w-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/loop-wv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^int main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/nested-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/nested-2.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/offset-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-1.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-2.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-3.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-4.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/par-reduction-2.c /^main (int argc, char *argv[])$/;" f +main testsuite/libgomp.oacc-c-c++-common/parallel-dims.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/parallel-empty.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/parallel-reduction.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/pointer-align-1.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/pr70289.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/pr70373.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/pr70688.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/present-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/present-2.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/private-variables.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-4.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-5.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-6.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^int main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-8.c /^main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^int main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^int main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^int main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^int main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/reduction-initial-1.c /^main(void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-1.c /^int main()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-4.c /^main(int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-g-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-gwv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-v-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-w-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-wv-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/update-1.c /^main (int argc, char **argv)$/;" f +main testsuite/libgomp.oacc-c-c++-common/vector-loop.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/vector-type-1.c /^int main(void)$/;" f +main testsuite/libgomp.oacc-c-c++-common/vprop.c /^main ()$/;" f +main testsuite/libgomp.oacc-c-c++-common/zero_length_subarrays.c /^main ()$/;" f +main testsuite/libgomp.oacc-c/nested-function-1.c /^main (void)$/;" f +main testsuite/libgomp.oacc-c/nested-function-2.c /^main (void)$/;" f +main testsuite/libgomp.oacc-fortran/abort-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/abort-2.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/atomic_capture-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/atomic_rw-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/atomic_update-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/clauses-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/combined-directives-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/declare-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/default-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/if-1.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-10.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-4.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-5.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-6.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-7.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/lib-8.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/openacc_version-1.f /^ program main$/;" p +main testsuite/libgomp.oacc-fortran/openacc_version-2.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/pr70643.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/private-variables.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/routine-5.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/routine-7.f90 /^program main$/;" p +main testsuite/libgomp.oacc-fortran/routine-9.f90 /^program main$/;" p +main1 testsuite/libgomp.c++/loop-1.C /^void main1()$/;" f +main1 testsuite/libgomp.c/omp-loop01.c /^void main1()$/;" f +map plugin/plugin-nvptx.c /^ bool map;$/;" m struct:ptx_device file: +map plugin/plugin-nvptx.c /^struct map$/;" s file: +map tdg.h /^ int map; \/\/ Thread assigned to the task by the static scheduler$/;" m struct:gomp_tdg_node +map_fini plugin/plugin-nvptx.c /^map_fini (struct ptx_stream *s)$/;" f file: +map_init plugin/plugin-nvptx.c /^map_init (struct ptx_stream *s)$/;" f file: +map_pop plugin/plugin-nvptx.c /^map_pop (struct ptx_stream *s)$/;" f file: +map_push plugin/plugin-nvptx.c /^map_push (struct ptx_stream *s, int async, size_t size, void **h, void **d)$/;" f file: +mapnum libgomp.h /^ size_t mapnum;$/;" m struct:gomp_target_task +mapped_data oacc-int.h /^ struct target_mem_desc *mapped_data;$/;" m struct:goacc_thread typeref:struct:goacc_thread::target_mem_desc +mappings plugin/plugin-nvptx.c /^ char mappings[0];$/;" m struct:map file: +master_release libgomp.h /^ gomp_sem_t master_release;$/;" m struct:gomp_team +matmul_depend testsuite/libgomp.c/examples-4/task_dep-5.c /^void matmul_depend (float A[N][N], float B[N][N], float C[N][N])$/;" f +matmul_depend testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ subroutine matmul_depend /;" s module:task_dep5_mod +matmul_ref testsuite/libgomp.c/examples-4/task_dep-5.c /^void matmul_ref (float A[N][N], float B[N][N], float C[N][N])$/;" f +matmul_ref testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ subroutine matmul_ref /;" s module:task_dep5_mod +max testsuite/libgomp.oacc-c-c++-common/reduction.h 40;" d +maxI_g tdg.c /^unsigned int *maxI_g; \/\/ maximum number of iterations of any loop containing #pragma omp tasks$/;" v +maxT_g tdg.c /^unsigned int *maxT_g; \/\/ number of tasks constructs (#pragma omp tasks) of the program$/;" v +max_dynamic_group_size plugin/hsa_ext_finalize.h /^ uint32_t max_dynamic_group_size;$/;" m struct:hsa_ext_control_directives_s +max_flat_grid_size plugin/hsa_ext_finalize.h /^ uint64_t max_flat_grid_size;$/;" m struct:hsa_ext_control_directives_s +max_flat_workgroup_size plugin/hsa_ext_finalize.h /^ uint32_t max_flat_workgroup_size;$/;" m struct:hsa_ext_control_directives_s +max_iters testsuite/libgomp.fortran/taskloop4.f90 /^ integer :: min_iters, max_iters,/;" v +max_omp_data_size plugin/plugin-hsa.c /^ unsigned max_omp_data_size;$/;" m struct:kernel_info file: +max_threads_per_block plugin/plugin-nvptx.c /^ int max_threads_per_block;$/;" m struct:targ_fn_descriptor file: +maybe_init_again testsuite/libgomp.c/examples-4/target_update-2.c /^int maybe_init_again (int *a, int N)$/;" f +maybe_init_again testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ logical function maybe_init_again /;" f module:e_52_2_mod +mem_map libgomp.h /^ struct splay_tree_s mem_map;$/;" m struct:gomp_device_descr typeref:struct:gomp_device_descr::splay_tree_s +memmodel libgomp.h /^enum memmodel$/;" g +min testsuite/libgomp.oacc-c-c++-common/reduction.h 41;" d +min_cpusetsize testsuite/libgomp.c/affinity-1.c /^unsigned long min_cpusetsize;$/;" v +min_iters testsuite/libgomp.fortran/taskloop4.f90 /^ integer :: min_iters,/;" v +mits testsuite/libgomp.fortran/jacobi.f /^ integer n,m,mits,/;" v program:main +mkern plugin/plugin-nvptx.c /^ bool mkern;$/;" m struct:ptx_device file: +mode libgomp.h /^ int mode;$/;" m struct:gomp_work_share +mode plugin/plugin-nvptx.c /^ int mode;$/;" m struct:ptx_device file: +modifier testsuite/libgomp.fortran/lib4.f90 /^ integer :: modifier$/;" v program:lib4 +module plugin/plugin-hsa.c /^ struct module_info *module;$/;" m struct:kernel_info typeref:struct:kernel_info::module_info file: +module plugin/plugin-nvptx.c /^ CUmodule module;$/;" m struct:ptx_image_data file: +module_info plugin/plugin-hsa.c /^struct module_info$/;" s file: +modules_rwlock plugin/plugin-hsa.c /^ pthread_rwlock_t modules_rwlock;$/;" m struct:agent_info file: +mtemp testsuite/libgomp.fortran/jacobi.f /^ integer n,m,mits,mtemp$/;" v program:main +multithreaded plugin/plugin-nvptx.c /^ bool multithreaded;$/;" m struct:ptx_stream file: +mutex config/posix/sem.h /^ pthread_mutex_t mutex;$/;" m struct:gomp_sem +mutex1 config/posix/bar.h /^ gomp_mutex_t mutex1;$/;" m struct:__anon35 +mutex2 config/posix/bar.h /^ gomp_mutex_t mutex2;$/;" m struct:__anon35 +myaddfloat testsuite/libgomp.c/examples-4/simd-6.c /^int myaddfloat(float *x, float *y, int n)$/;" f +myaddfloat testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function myaddfloat(/;" f module:SIMD6_mod +myaddfloat_ref testsuite/libgomp.c/examples-4/simd-6.c /^int myaddfloat_ref(float *x, float *y, int n)$/;" f +myaddfloat_ref testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function myaddfloat_ref(/;" f module:SIMD6_mod +myaddint testsuite/libgomp.c/examples-4/simd-6.c /^int myaddint(int *a, int *b, int n)$/;" f +myaddint testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function myaddint(/;" f module:SIMD6_mod +myaddint_ref testsuite/libgomp.c/examples-4/simd-6.c /^int myaddint_ref(int *a, int *b, int n)$/;" f +myaddint_ref testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ function myaddint_ref(/;" f module:SIMD6_mod +n testsuite/libgomp.c++/ctor-12.C /^static int n;$/;" v file: +n testsuite/libgomp.c++/ctor-13.C /^static int n;$/;" v file: +n testsuite/libgomp.c++/pr26691.C /^ int n;$/;" m struct:A file: +n testsuite/libgomp.c++/pr27337.C /^int n[3];$/;" v +n testsuite/libgomp.c/pr26943-1.c /^int n = 6;$/;" v +n testsuite/libgomp.c/pr39154.c /^int n = 20;$/;" v +n testsuite/libgomp.fortran/allocatable2.f90 /^ int/;" v +n testsuite/libgomp.fortran/examples-4/target-1.f90 /^ int/;" v program:e_50_1 +n testsuite/libgomp.fortran/examples-4/target-2.f90 /^ int/;" v program:e_50_2 +n testsuite/libgomp.fortran/examples-4/target-3.f90 /^ int/;" v program:e_50_3 +n testsuite/libgomp.fortran/examples-4/target-4.f90 /^ int/;" v program:e_50_4 +n testsuite/libgomp.fortran/examples-4/target-5.f90 /^ int/;" v program:e_50_5 +n testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^ int/;" v program:e_51_1 +n testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^ int/;" v program:e_51_2 +n testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ int/;" v program:e_51_4 +n testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^ int/;" v program:e_51_6 +n testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^ int/;" v program:e_51_7 +n testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ int/;" v program:e_52_1 +n testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ int/;" v program:e_52_2 +n testsuite/libgomp.fortran/examples-4/teams-2.f90 /^ int/;" v program:e_54_1 +n testsuite/libgomp.fortran/examples-4/teams-3.f90 /^ int/;" v program:e_54_3 +n testsuite/libgomp.fortran/examples-4/teams-4.f90 /^ int/;" v program:e_54_4 +n testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ int/;" v program:e_54_5 +n testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ int/;" v program:e_54_6 +n testsuite/libgomp.fortran/jacobi.f /^ int/;" v program:main +n testsuite/libgomp.fortran/omp_atomic2.f90 /^ int/;" v +n testsuite/libgomp.fortran/parloops-exit-first-loop-alt-2.f95 /^ int/;" v program:main +n testsuite/libgomp.fortran/parloops-exit-first-loop-alt.f95 /^ int/;" v program:main +n testsuite/libgomp.fortran/pr27395-1.f90 /^ int/;" v program:pr27395_1 +n testsuite/libgomp.fortran/pr27395-2.f90 /^ int/;" v program:pr27395_2 +n testsuite/libgomp.fortran/pr27916-1.f90 /^ int/;" v program:pr27916 +n testsuite/libgomp.fortran/pr27916-2.f90 /^ int/;" v program:pr27916 +n testsuite/libgomp.fortran/pr29629.f90 /^ int/;" v program:pr29629 +n testsuite/libgomp.fortran/pr66680.f90 /^ int/;" v module:m1 +n testsuite/libgomp.fortran/reduction1.f90 /^ int/;" v +n testsuite/libgomp.fortran/reduction2.f90 /^ int/;" v +n testsuite/libgomp.fortran/reduction3.f90 /^ int/;" v +n testsuite/libgomp.fortran/reduction4.f90 /^ int/;" v +n testsuite/libgomp.fortran/sharing2.f90 /^ int/;" v +n testsuite/libgomp.fortran/simd7.f90 /^ int/;" v +n testsuite/libgomp.fortran/target1.f90 /^ int/;" v +n testsuite/libgomp.fortran/target2.f90 /^ int/;" v +n testsuite/libgomp.fortran/target6.f90 /^ int/;" v +n testsuite/libgomp.fortran/target7.f90 /^ int/;" v +n testsuite/libgomp.fortran/target8.f90 /^ int/;" v +n testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n,/;" v +n testsuite/libgomp.oacc-c++/template-reduction.C /^const int n = 100;$/;" v +n testsuite/libgomp.oacc-c-c++-common/kernels-reduction.c 3;" d file: +n testsuite/libgomp.oacc-c-c++-common/pr70688.c /^const int n = 100;$/;" v +n testsuite/libgomp.oacc-c-c++-common/reduction-5.c /^const int n = 100;$/;" v +n testsuite/libgomp.oacc-c-c++-common/reduction-8.c /^const int n = 100;$/;" v +n testsuite/libgomp.oacc-c-c++-common/vector-loop.c /^unsigned int n = N;$/;" v +n testsuite/libgomp.oacc-c-c++-common/zero_length_subarrays.c /^const int n = 10;$/;" v +n testsuite/libgomp.oacc-fortran/combined-directives-1.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/combined-reduction.f90 /^ int/;" v program:test +n testsuite/libgomp.oacc-fortran/firstprivate-1.f90 /^ int/;" v program:firstprivate +n testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-2.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop-data.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/kernels-loop.f95 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/lib-4.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/lib-5.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/lib-6.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/lib-7.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/map-1.f90 /^ int/;" v +n testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/parallel-reduction.f90 /^ int/;" v program:reduction +n testsuite/libgomp.oacc-fortran/pr68813.f90 /^ int/;" v program:foo +n testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ int/;" v program:reduction_1 +n testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ int/;" v program:reduction_2 +n testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ int/;" v program:reduction_3 +n testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ int/;" v program:reduction_4 +n testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ int/;" v program:reduction +n testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ int/;" v program:reduction +n testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ int/;" v program:reduction +n testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ int/;" v program:reduction +n testsuite/libgomp.oacc-fortran/routine-1.f90 /^ int/;" v +n testsuite/libgomp.oacc-fortran/routine-2.f90 /^ int/;" v +n testsuite/libgomp.oacc-fortran/routine-3.f90 /^ int/;" v +n testsuite/libgomp.oacc-fortran/routine-4.f90 /^ int/;" v +n testsuite/libgomp.oacc-fortran/routine-5.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/routine-9.f90 /^ int/;" v program:main +n testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^ int/;" v program:subarrays +n testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^ int/;" v program:subarrays +n2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer, parameter :: n = 100, n2 /;" v program:reduction +nEvents testsuite/libgomp.c/pr46032.c 7;" d file: +n_deleted hashtab.h /^ size_t n_deleted;$/;" m struct:htab +n_depend libgomp.h /^ size_t n_depend;$/;" m struct:gomp_taskwait +n_elem libgomp.h /^ size_t n_elem;$/;" m struct:gomp_dependers_vec +n_elements hashtab.h /^ size_t n_elements;$/;" m struct:htab +name libgomp.h /^ const char *name;$/;" m struct:gomp_device_descr +name plugin/plugin-hsa.c /^ const char *name;$/;" m struct:global_var_info file: +name plugin/plugin-hsa.c /^ const char *name;$/;" m struct:hsa_kernel_description file: +name plugin/plugin-hsa.c /^ const char *name;$/;" m struct:kernel_info file: +name testsuite/libgomp.c/affinity-1.c /^ char name[40];$/;" m struct:places file: +name_of_acc_device_t oacc-init.c /^name_of_acc_device_t (enum acc_device_t type)$/;" f file: +ncounts libgomp.h /^ unsigned int ncounts;$/;" m struct:gomp_doacross_work_share +ndim plugin/plugin-hsa.c /^ uint32_t ndim;$/;" m struct:GOMP_kernel_launch_attributes file: +nest_var libgomp.h /^ bool nest_var;$/;" m struct:gomp_task_icv +nested team.c /^ bool nested;$/;" m struct:gomp_thread_start_data file: +nested1 testsuite/libgomp.fortran/nested1.f90 /^program nested1$/;" p +nestomp testsuite/libgomp.fortran/nestedfn3.f90 /^program nestomp$/;" p +new_lock testsuite/libgomp.c/appendix-a/a.33.3.c /^new_lock ()$/;" f +next libgomp.h /^ long next;$/;" m union:gomp_work_share::__anon50 +next libgomp.h /^ struct gomp_task_depend_entry *next;$/;" m struct:gomp_task_depend_entry typeref:struct:gomp_task_depend_entry::gomp_task_depend_entry +next oacc-int.h /^ struct goacc_thread *next;$/;" m struct:goacc_thread typeref:struct:goacc_thread::goacc_thread +next plugin/plugin-hsa.c /^ struct module_info *next, *prev;$/;" m struct:module_info typeref:struct:module_info::module_info file: +next plugin/plugin-nvptx.c /^ struct ptx_device *next;$/;" m struct:ptx_device typeref:struct:ptx_device::ptx_device file: +next plugin/plugin-nvptx.c /^ struct ptx_event *next;$/;" m struct:ptx_event typeref:struct:ptx_event::ptx_event file: +next plugin/plugin-nvptx.c /^ struct ptx_image_data *next;$/;" m struct:ptx_image_data typeref:struct:ptx_image_data::ptx_image_data file: +next plugin/plugin-nvptx.c /^ struct ptx_stream *next;$/;" m struct:ptx_stream typeref:struct:ptx_stream::ptx_stream file: +next priority_queue.h /^ struct priority_node *next, *prev;$/;" m struct:priority_node typeref:struct:priority_node::priority_node +next tdg.h /^ struct data_to_free *next;$/;" m struct:data_to_free typeref:struct:data_to_free::data_to_free +next tdg.h /^ struct root_list *next; \/\/ pointer to the next node$/;" m struct:root_list typeref:struct:root_list::root_list +next tdg.h /^ struct tdg_func_hash_entry *next;$/;" m struct:tdg_func_hash_entry typeref:struct:tdg_func_hash_entry::tdg_func_hash_entry +next testsuite/libgomp.c/ordered-2.c /^static int next;$/;" v file: +next_alloc libgomp.h /^ struct gomp_work_share *next_alloc;$/;" m struct:gomp_work_share typeref:struct:gomp_work_share::gomp_work_share +next_free libgomp.h /^ struct gomp_work_share *next_free;$/;" m union:gomp_work_share::__anon51 typeref:struct:gomp_work_share::__anon51::gomp_work_share +next_ull libgomp.h /^ unsigned long long next_ull;$/;" m union:gomp_work_share::__anon50 +next_waiting_tdg tdg.h /^ struct gomp_tdg_node *next_waiting_tdg; \/\/to fit mcxx implementation$/;" m struct:gomp_tdg_node typeref:struct:gomp_tdg_node::gomp_tdg_node +next_ws libgomp.h /^ gomp_ptrlock_t next_ws;$/;" m union:gomp_work_share::__anon51 +ng testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^const int ng = 8;$/;" v +ng testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^const int ng = 8;$/;" v +ng testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^const int ng = 8;$/;" v +ng testsuite/libgomp.oacc-c-c++-common/reduction-4.c /^const int ng = 8;$/;" v +ng testsuite/libgomp.oacc-c-c++-common/reduction-5.c /^const int ng = 8;$/;" v +ng testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer, parameter :: n = 10, ng /;" v program:reduction_1 +ng testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ integer, parameter :: n = 10, ng /;" v program:reduction_2 +ng testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ integer, parameter :: n = 10, ng /;" v program:reduction_3 +ng testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ integer, parameter :: n = 10, ng /;" v program:reduction_4 +nin tdg.h /^ char nin; \/\/ Number of input dependencies$/;" m struct:gomp_tdg_node +nlck testsuite/libgomp.fortran/lib1.f90 /^ integer (kind = omp_nest_lock_kind) :: nlck$/;" v +nn testsuite/libgomp.oacc-fortran/if-1.f90 /^ integer i, nn$/;" v program:main +noreturn testsuite/libgomp.c/for-2.h /^noreturn (void)$/;" f +nout tdg.h /^ char nout; \/\/ Number of output dependencies$/;" m struct:gomp_tdg_node +nqueens testsuite/libgomp.c/nqueens-1.c /^nqueens (char *a, int n, int pos)$/;" f +ns testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsum, gs, ws, vs, cs, ns$/;" v program:reduction +ntasks testsuite/libgomp.fortran/taskloop4.f90 /^ integer :: min_iters, max_iters, ntasks,/;" v +nthr testsuite/libgomp.c/parallel-1.c /^static int nthr;$/;" v file: +nthreads libgomp.h /^ unsigned nthreads;$/;" m struct:gomp_team +nthreads testsuite/libgomp.c++/ctor-1.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-11.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-2.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-3.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-4.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-5.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-6.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.c++/ctor-7.C /^static int nthreads;$/;" v file: +nthreads testsuite/libgomp.fortran/reduction6.f90 /^ integer nthreads$/;" v +nthreads_var libgomp.h /^ unsigned long nthreads_var;$/;" m struct:gomp_task_icv +null_stream plugin/plugin-nvptx.c /^ struct ptx_stream *null_stream;$/;" m struct:ptx_device typeref:struct:ptx_device::ptx_stream file: +num testsuite/libgomp.fortran/affinity1.f90 /^ integer :: num,/;" v +num testsuite/libgomp.fortran/examples-4/device-2.f90 /^ integer :: i, num$/;" v program:e_57_2 +num_children libgomp.h /^ size_t num_children;$/;" m struct:gomp_taskgroup +num_dependees libgomp.h /^ size_t num_dependees;$/;" m struct:gomp_task +num_devices target.c /^static int num_devices;$/;" v file: +num_devices_openmp target.c /^static int num_devices_openmp;$/;" v file: +num_offload_images target.c /^static int num_offload_images;$/;" v file: +num_output_g tdg.c /^unsigned int num_output_g = 0; \/\/ size of output array$/;" v +num_sms plugin/plugin-nvptx.c /^ int num_sms;$/;" m struct:ptx_device file: +num_tasks testsuite/libgomp.c/taskloop-4.c /^num_tasks (int a, int b, int c, int d)$/;" f +num_tasks testsuite/libgomp.fortran/taskloop4.f90 /^ subroutine num_tasks /;" s +num_tasks_g tdg.c /^unsigned int num_tasks_g = 0; \/\/ size of tdg array$/;" v +num_tdgs_g tdg.c /^unsigned int num_tdgs_g; \/\/ total number of tdgs of the program$/;" v +num_threads testsuite/libgomp.c/atomic-3.c /^int num_threads;$/;" v +nump testsuite/libgomp.fortran/affinity1.f90 /^ integer :: num, i, nump$/;" v +nvptx_adjust_launch_bounds plugin/plugin-nvptx.c /^nvptx_adjust_launch_bounds (struct targ_fn_descriptor *fn,$/;" f file: +nvptx_alloc plugin/plugin-nvptx.c /^nvptx_alloc (size_t s)$/;" f file: +nvptx_async_test plugin/plugin-nvptx.c /^nvptx_async_test (int async)$/;" f file: +nvptx_async_test_all plugin/plugin-nvptx.c /^nvptx_async_test_all (void)$/;" f file: +nvptx_attach_host_thread_to_device plugin/plugin-nvptx.c /^nvptx_attach_host_thread_to_device (int n)$/;" f file: +nvptx_close_device plugin/plugin-nvptx.c /^nvptx_close_device (struct ptx_device *ptx_dev)$/;" f file: +nvptx_dev2host plugin/plugin-nvptx.c /^nvptx_dev2host (void *h, const void *d, size_t s)$/;" f file: +nvptx_exec plugin/plugin-nvptx.c /^nvptx_exec (void (*fn), size_t mapnum, void **hostaddrs, void **devaddrs,$/;" f file: +nvptx_free plugin/plugin-nvptx.c /^nvptx_free (void *p)$/;" f file: +nvptx_get_cuda_stream plugin/plugin-nvptx.c /^nvptx_get_cuda_stream (int async)$/;" f file: +nvptx_get_current_cuda_context plugin/plugin-nvptx.c /^nvptx_get_current_cuda_context (void)$/;" f file: +nvptx_get_current_cuda_device plugin/plugin-nvptx.c /^nvptx_get_current_cuda_device (void)$/;" f file: +nvptx_get_num_devices plugin/plugin-nvptx.c /^nvptx_get_num_devices (void)$/;" f file: +nvptx_host2dev plugin/plugin-nvptx.c /^nvptx_host2dev (void *d, const void *h, size_t s)$/;" f file: +nvptx_init plugin/plugin-nvptx.c /^nvptx_init (void)$/;" f file: +nvptx_open_device plugin/plugin-nvptx.c /^nvptx_open_device (int n)$/;" f file: +nvptx_set_async plugin/plugin-nvptx.c /^nvptx_set_async (int async)$/;" f file: +nvptx_set_clocktick plugin/plugin-nvptx.c /^nvptx_set_clocktick (CUmodule module, struct ptx_device *dev)$/;" f file: +nvptx_set_cuda_stream plugin/plugin-nvptx.c /^nvptx_set_cuda_stream (int async, void *stream)$/;" f file: +nvptx_stacks_alloc plugin/plugin-nvptx.c /^nvptx_stacks_alloc (size_t size, int num)$/;" f file: +nvptx_stacks_free plugin/plugin-nvptx.c /^nvptx_stacks_free (void *p, int num)$/;" f file: +nvptx_stacks_size plugin/plugin-nvptx.c /^nvptx_stacks_size ()$/;" f file: +nvptx_tdata plugin/plugin-nvptx.c /^typedef struct nvptx_tdata$/;" s file: +nvptx_tdata_t plugin/plugin-nvptx.c /^} nvptx_tdata_t;$/;" t typeref:struct:nvptx_tdata file: +nvptx_thread plugin/plugin-nvptx.c /^nvptx_thread (void)$/;" f file: +nvptx_thread plugin/plugin-nvptx.c /^struct nvptx_thread$/;" s file: +nvptx_thrs config/nvptx/team.c /^struct gomp_thread *nvptx_thrs __attribute__((shared,nocommon));$/;" v typeref:struct:gomp_thread +nvptx_wait plugin/plugin-nvptx.c /^nvptx_wait (int async)$/;" f file: +nvptx_wait_all plugin/plugin-nvptx.c /^nvptx_wait_all (void)$/;" f file: +nvptx_wait_all_async plugin/plugin-nvptx.c /^nvptx_wait_all_async (int async)$/;" f file: +nvptx_wait_async plugin/plugin-nvptx.c /^nvptx_wait_async (int async1, int async2)$/;" f file: +nw testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^const int nw = 4;$/;" v +nw testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^const int nw = 4;$/;" v +nw testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^const int nw = 4;$/;" v +nw testsuite/libgomp.oacc-c-c++-common/reduction-4.c /^const int nw = 4;$/;" v +nw testsuite/libgomp.oacc-c-c++-common/reduction-5.c /^const int nw = 4;$/;" v +nw testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer, parameter :: n = 10, ng = 8, nw /;" v program:reduction_1 +nw testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ integer, parameter :: n = 10, ng = 8, nw /;" v program:reduction_2 +nw testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ integer, parameter :: n = 10, ng = 8, nw /;" v program:reduction_3 +nw testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ integer, parameter :: n = 10, ng = 8, nw /;" v program:reduction_4 +o testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n, o,/;" v +object plugin/plugin-hsa.c /^ uint64_t object;$/;" m struct:GOMP_hsa_kernel_dispatch file: +object plugin/plugin-hsa.c /^ uint64_t object;$/;" m struct:kernel_info file: +offin tdg.h /^ unsigned short offin; \/\/ Starting position within the tomp_tdg_ins structure$/;" m struct:gomp_tdg_node +offload testsuite/libgomp.fortran/examples-4/device-2.f90 /^ logical :: offload(/;" v program:e_57_2 +offload_image_descr target.c /^struct offload_image_descr {$/;" s file: +offload_images target.c /^static struct offload_image_descr *offload_images;$/;" v typeref:struct:offload_image_descr file: +offload_target_type libgomp-plugin.h /^enum offload_target_type$/;" g +offout tdg.h /^ unsigned short offout; \/\/ Starting position within the tomp_tdg_outs structure$/;" m struct:gomp_tdg_node +offset libgomp.h /^ uintptr_t offset;$/;" m struct:target_var_desc +offset plugin/hsa_ext_finalize.h /^ hsa_dim3_t offset;$/;" m struct:hsa_ext_image_region_s +offset testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ integer, target:: offset$/;" v program:SIMD1 +omp_data_memory plugin/plugin-hsa.c /^ void *omp_data_memory;$/;" m struct:GOMP_hsa_kernel_dispatch file: +omp_data_size plugin/plugin-hsa.c /^ unsigned omp_data_size;$/;" m struct:hsa_kernel_description file: +omp_data_size plugin/plugin-hsa.c /^ unsigned omp_data_size;$/;" m struct:kernel_info file: +omp_get_active_level parallel.c /^omp_get_active_level (void)$/;" f +omp_get_active_level_ fortran.c /^omp_get_active_level_ (void)$/;" f +omp_get_ancestor_thread_num parallel.c /^omp_get_ancestor_thread_num (int level)$/;" f +omp_get_ancestor_thread_num_ fortran.c /^omp_get_ancestor_thread_num_ (const int32_t *level)$/;" f +omp_get_ancestor_thread_num_8_ fortran.c /^omp_get_ancestor_thread_num_8_ (const int64_t *level)$/;" f +omp_get_cancellation icv.c /^omp_get_cancellation (void)$/;" f +omp_get_cancellation_ fortran.c /^omp_get_cancellation_ (void)$/;" f +omp_get_default_device config/nvptx/icv-device.c /^omp_get_default_device (void)$/;" f +omp_get_default_device icv-device.c /^omp_get_default_device (void)$/;" f +omp_get_default_device_ fortran.c /^omp_get_default_device_ (void)$/;" f +omp_get_dynamic icv.c /^omp_get_dynamic (void)$/;" f +omp_get_dynamic_ fortran.c /^omp_get_dynamic_ (void)$/;" f +omp_get_initial_device icv.c /^omp_get_initial_device (void)$/;" f +omp_get_initial_device_ fortran.c /^omp_get_initial_device_ (void)$/;" f +omp_get_level parallel.c /^omp_get_level (void)$/;" f +omp_get_level_ fortran.c /^omp_get_level_ (void)$/;" f +omp_get_max_active_levels icv.c /^omp_get_max_active_levels (void)$/;" f +omp_get_max_active_levels_ fortran.c /^omp_get_max_active_levels_ (void)$/;" f +omp_get_max_task_priority icv.c /^omp_get_max_task_priority (void)$/;" f +omp_get_max_task_priority_ fortran.c /^omp_get_max_task_priority_ (void)$/;" f +omp_get_max_threads icv.c /^omp_get_max_threads (void)$/;" f +omp_get_max_threads_ fortran.c /^omp_get_max_threads_ (void)$/;" f +omp_get_nested icv.c /^omp_get_nested (void)$/;" f +omp_get_nested_ fortran.c /^omp_get_nested_ (void)$/;" f +omp_get_num_devices config/nvptx/icv-device.c /^omp_get_num_devices (void)$/;" f +omp_get_num_devices icv-device.c /^omp_get_num_devices (void)$/;" f +omp_get_num_devices_ fortran.c /^omp_get_num_devices_ (void)$/;" f +omp_get_num_places icv.c /^omp_get_num_places (void)$/;" f +omp_get_num_places_ fortran.c /^omp_get_num_places_ (void)$/;" f +omp_get_num_procs config/bsd/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs config/linux/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs config/mingw32/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs config/nvptx/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs config/posix/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs config/rtems/proc.c /^omp_get_num_procs (void)$/;" f +omp_get_num_procs_ fortran.c /^omp_get_num_procs_ (void)$/;" f +omp_get_num_teams config/nvptx/icv-device.c /^omp_get_num_teams (void)$/;" f +omp_get_num_teams icv-device.c /^omp_get_num_teams (void)$/;" f +omp_get_num_teams_ fortran.c /^omp_get_num_teams_ (void)$/;" f +omp_get_num_threads parallel.c /^omp_get_num_threads (void)$/;" f +omp_get_num_threads_ fortran.c /^omp_get_num_threads_ (void)$/;" f +omp_get_partition_num_places icv.c /^omp_get_partition_num_places (void)$/;" f +omp_get_partition_num_places_ fortran.c /^omp_get_partition_num_places_ (void)$/;" f +omp_get_partition_place_nums icv.c /^omp_get_partition_place_nums (int *place_nums)$/;" f +omp_get_partition_place_nums_ fortran.c /^omp_get_partition_place_nums_ (int32_t *place_nums)$/;" f +omp_get_partition_place_nums_8_ fortran.c /^omp_get_partition_place_nums_8_ (int64_t *place_nums)$/;" f +omp_get_place_num icv.c /^omp_get_place_num (void)$/;" f +omp_get_place_num_ fortran.c /^omp_get_place_num_ (void)$/;" f +omp_get_place_num_procs affinity.c /^omp_get_place_num_procs (int place_num)$/;" f +omp_get_place_num_procs config/linux/affinity.c /^omp_get_place_num_procs (int place_num)$/;" f +omp_get_place_num_procs_ fortran.c /^omp_get_place_num_procs_ (const int32_t *place_num)$/;" f +omp_get_place_num_procs_8_ fortran.c /^omp_get_place_num_procs_8_ (const int64_t *place_num)$/;" f +omp_get_place_proc_ids affinity.c /^omp_get_place_proc_ids (int place_num, int *ids)$/;" f +omp_get_place_proc_ids config/linux/affinity.c /^omp_get_place_proc_ids (int place_num, int *ids)$/;" f +omp_get_place_proc_ids_ fortran.c /^omp_get_place_proc_ids_ (const int32_t *place_num, int32_t *ids)$/;" f +omp_get_place_proc_ids_8_ fortran.c /^omp_get_place_proc_ids_8_ (const int64_t *place_num, int64_t *ids)$/;" f +omp_get_proc_bind icv.c /^omp_get_proc_bind (void)$/;" f +omp_get_proc_bind_ fortran.c /^omp_get_proc_bind_ (void)$/;" f +omp_get_schedule icv.c /^omp_get_schedule (omp_sched_t *kind, int *chunk_size)$/;" f +omp_get_schedule_ fortran.c /^omp_get_schedule_ (int32_t *kind, int32_t *chunk_size)$/;" f +omp_get_schedule_8_ fortran.c /^omp_get_schedule_8_ (int32_t *kind, int64_t *chunk_size)$/;" f +omp_get_team_num config/nvptx/icv-device.c /^omp_get_team_num (void)$/;" f +omp_get_team_num icv-device.c /^omp_get_team_num (void)$/;" f +omp_get_team_num_ fortran.c /^omp_get_team_num_ (void)$/;" f +omp_get_team_size parallel.c /^omp_get_team_size (int level)$/;" f +omp_get_team_size_ fortran.c /^omp_get_team_size_ (const int32_t *level)$/;" f +omp_get_team_size_8_ fortran.c /^omp_get_team_size_8_ (const int64_t *level)$/;" f +omp_get_thread_limit icv.c /^omp_get_thread_limit (void)$/;" f +omp_get_thread_limit_ fortran.c /^omp_get_thread_limit_ (void)$/;" f +omp_get_thread_num parallel.c /^omp_get_thread_num (void)$/;" f +omp_get_thread_num testsuite/libgomp.fortran/stack.f90 /^ integer omp_get_thread_num,/;" v program:stack +omp_get_thread_num_ fortran.c /^omp_get_thread_num_ (void)$/;" f +omp_get_wtick config/mingw32/time.c /^omp_get_wtick (void)$/;" f +omp_get_wtick config/nvptx/time.c /^omp_get_wtick (void)$/;" f +omp_get_wtick config/posix/time.c /^omp_get_wtick (void)$/;" f +omp_get_wtick_ fortran.c /^omp_get_wtick_ (void)$/;" f +omp_get_wtime config/mingw32/time.c /^omp_get_wtime (void)$/;" f +omp_get_wtime config/nvptx/time.c /^omp_get_wtime (void)$/;" f +omp_get_wtime config/posix/time.c /^omp_get_wtime (void)$/;" f +omp_get_wtime_ fortran.c /^omp_get_wtime_ (void)$/;" f +omp_in testsuite/libgomp.fortran/udr7.f90 /^ elemental real function omp_in /;" f program:udr7 +omp_in_final task.c /^omp_in_final (void)$/;" f +omp_in_final_ fortran.c /^omp_in_final_ (void)$/;" f +omp_in_parallel parallel.c /^omp_in_parallel (void)$/;" f +omp_in_parallel_ fortran.c /^omp_in_parallel_ (void)$/;" f +omp_is_initial_device config/nvptx/icv-device.c /^omp_is_initial_device (void)$/;" f +omp_is_initial_device icv-device.c /^omp_is_initial_device (void)$/;" f +omp_is_initial_device_ fortran.c /^omp_is_initial_device_ (void)$/;" f +omp_level plugin/plugin-hsa.c /^ uint64_t omp_level;$/;" m struct:GOMP_hsa_kernel_dispatch file: +omp_lock_25_t config/linux/omp-lock.h /^typedef int omp_lock_25_t;$/;" t +omp_lock_25_t config/nvptx/omp-lock.h /^typedef int omp_lock_25_t;$/;" t +omp_lock_25_t config/posix/omp-lock.h /^typedef pthread_mutex_t omp_lock_25_t;$/;" t +omp_lock_symver fortran.c /^omp_lock_symver (omp_init_lock_)$/;" f +omp_lock_symver libgomp.h 1105;" d +omp_lock_t config/linux/omp-lock.h /^typedef int omp_lock_t;$/;" t +omp_lock_t config/nvptx/omp-lock.h /^typedef int omp_lock_t;$/;" t +omp_lock_t config/posix/omp-lock.h /^typedef pthread_mutex_t omp_lock_t;$/;" t +omp_lock_t config/posix/omp-lock.h /^typedef sem_t omp_lock_t;$/;" t +omp_nest_lock_25_t config/linux/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" t typeref:struct:__anon41 +omp_nest_lock_25_t config/nvptx/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" t typeref:struct:__anon37 +omp_nest_lock_25_t config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; } omp_nest_lock_25_t;$/;" t typeref:struct:__anon30 +omp_nest_lock_t config/linux/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" t typeref:struct:__anon40 +omp_nest_lock_t config/nvptx/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" t typeref:struct:__anon36 +omp_nest_lock_t config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; void *owner; } omp_nest_lock_t;$/;" t typeref:struct:__anon31 +omp_nest_lock_t config/posix/omp-lock.h /^typedef struct { sem_t lock; int count; void *owner; } omp_nest_lock_t;$/;" t typeref:struct:__anon32 +omp_num_threads plugin/plugin-hsa.c /^ uint32_t omp_num_threads;$/;" m struct:GOMP_hsa_kernel_dispatch file: +omp_orig testsuite/libgomp.fortran/udr7.f90 /^elemental real function omp_orig /;" f +omp_out testsuite/libgomp.fortran/udr7.f90 /^ elemental subroutine omp_out /;" s program:udr7 +omp_priv testsuite/libgomp.fortran/udr7.f90 /^elemental subroutine omp_priv /;" s +omp_set_default_device config/nvptx/icv-device.c /^omp_set_default_device (int device_num __attribute__((unused)))$/;" f +omp_set_default_device icv-device.c /^omp_set_default_device (int device_num)$/;" f +omp_set_default_device_ fortran.c /^omp_set_default_device_ (const int32_t *device_num)$/;" f +omp_set_default_device_8_ fortran.c /^omp_set_default_device_8_ (const int64_t *device_num)$/;" f +omp_set_dynamic icv.c /^omp_set_dynamic (int val)$/;" f +omp_set_dynamic_8_ fortran.c /^omp_set_dynamic_8_ (const int64_t *set)$/;" f +omp_set_max_active_levels icv.c /^omp_set_max_active_levels (int max_levels)$/;" f +omp_set_max_active_levels_ fortran.c /^omp_set_max_active_levels_ (const int32_t *levels)$/;" f +omp_set_max_active_levels_8_ fortran.c /^omp_set_max_active_levels_8_ (const int64_t *levels)$/;" f +omp_set_nested icv.c /^omp_set_nested (int val)$/;" f +omp_set_nested_ fortran.c /^omp_set_nested_ (const int32_t *set)$/;" f +omp_set_nested_8_ fortran.c /^omp_set_nested_8_ (const int64_t *set)$/;" f +omp_set_num_threads icv.c /^omp_set_num_threads (int n)$/;" f +omp_set_num_threads_ fortran.c /^omp_set_num_threads_ (const int32_t *set)$/;" f +omp_set_num_threads_8_ fortran.c /^omp_set_num_threads_8_ (const int64_t *set)$/;" f +omp_set_schedule icv.c /^omp_set_schedule (omp_sched_t kind, int chunk_size)$/;" f +omp_set_schedule_ fortran.c /^omp_set_schedule_ (const int32_t *kind, const int32_t *chunk_size)$/;" f +omp_set_schedule_8_ fortran.c /^omp_set_schedule_8_ (const int32_t *kind, const int64_t *chunk_size)$/;" f +omp_target_alloc target.c /^omp_target_alloc (size_t size, int device_num)$/;" f +omp_target_associate_ptr target.c /^omp_target_associate_ptr (void *host_ptr, void *device_ptr, size_t size,$/;" f +omp_target_disassociate_ptr target.c /^omp_target_disassociate_ptr (void *ptr, int device_num)$/;" f +omp_target_free target.c /^omp_target_free (void *device_ptr, int device_num)$/;" f +omp_target_is_present target.c /^omp_target_is_present (void *ptr, int device_num)$/;" f +omp_target_memcpy target.c /^omp_target_memcpy (void *dst, void *src, size_t length, size_t dst_offset,$/;" f +omp_target_memcpy_rect target.c /^omp_target_memcpy_rect (void *dst, void *src, size_t element_size,$/;" f +omp_target_memcpy_rect_worker target.c /^omp_target_memcpy_rect_worker (void *dst, void *src, size_t element_size,$/;" f file: +one testsuite/libgomp.fortran/udr5.f90 /^ type(dt) :: xdt, one$/;" v program:udr5 +one testsuite/libgomp.fortran/udr6.f90 /^ type(dt) :: one$/;" v program:udr6 +one testsuite/libgomp.oacc-fortran/if-1.f90 /^ integer, parameter :: one /;" v program:main +openacc config/nvptx/openacc.f90 /^module openacc$/;" m +openacc libgomp.h /^ acc_dispatch_t openacc;$/;" m struct:gomp_device_descr +openacc openacc.f90 /^module openacc$/;" m +openacc_internal config/nvptx/openacc.f90 /^module openacc_internal$/;" m +openacc_internal openacc.f90 /^module openacc_internal$/;" m +openacc_kinds config/nvptx/openacc.f90 /^module openacc_kinds$/;" m +openacc_kinds openacc.f90 /^module openacc_kinds$/;" m +openacc_version openacc.f90 /^ integer, parameter :: openacc_version /;" v module:openacc +operator != testsuite/libgomp.c++/collapse-2.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/collapse-2.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/doacross-1.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/doacross-1.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-1.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-1.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-5.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-5.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-8.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/for-8.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/member-5.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/member-5.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/taskloop-6.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/taskloop-6.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/taskloop-9.C /^template bool operator != (I &x, I &y) { return !(x == y); }$/;" f +operator != testsuite/libgomp.c++/taskloop-9.C /^template bool operator != (const I &x, const I &y) { return !(x == y); }$/;" f +operator * testsuite/libgomp.c++/collapse-2.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/doacross-1.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/for-1.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/for-5.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/for-8.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/member-5.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/taskloop-6.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator * testsuite/libgomp.c++/taskloop-9.C /^template T &I::operator * () { return *p; }$/;" f class:I +operator + testsuite/libgomp.c++/collapse-2.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/collapse-2.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/doacross-1.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/doacross-1.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/for-1.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/for-1.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/for-5.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/for-5.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/for-8.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/for-8.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/member-5.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/member-5.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/taskloop-6.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/taskloop-6.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator + testsuite/libgomp.c++/taskloop-9.C /^template I I::operator + (const difference_type &x) const { return I (p + x); }$/;" f class:I +operator + testsuite/libgomp.c++/taskloop-9.C /^template I operator + (typename I::difference_type x, const I &y) { return I (x + y.p); }$/;" f +operator ++ testsuite/libgomp.c++/collapse-2.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/collapse-2.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/doacross-1.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/doacross-1.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-1.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-1.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-5.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-5.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-8.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/for-8.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/member-5.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/member-5.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/taskloop-6.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/taskloop-6.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator ++ testsuite/libgomp.c++/taskloop-9.C /^template I &I::operator ++ () { ++p; return *this; }$/;" f class:I +operator ++ testsuite/libgomp.c++/taskloop-9.C /^template I I::operator ++ (int) { return I (p++); }$/;" f class:I +operator += testsuite/libgomp.c++/collapse-2.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/doacross-1.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/for-1.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/for-5.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/for-8.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/member-5.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/taskloop-6.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator += testsuite/libgomp.c++/taskloop-9.C /^template I &I::operator += (const difference_type &x) { p += x; return *this; }$/;" f class:I +operator - testsuite/libgomp.c++/collapse-2.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/collapse-2.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/collapse-2.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/doacross-1.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/doacross-1.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/doacross-1.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-1.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/for-1.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-1.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-5.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/for-5.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-5.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-8.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/for-8.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/for-8.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/member-5.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/member-5.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/member-5.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/taskloop-6.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/taskloop-6.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/taskloop-6.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/taskloop-9.C /^template I I::operator - (const difference_type &x) const { return I (p - x); }$/;" f class:I +operator - testsuite/libgomp.c++/taskloop-9.C /^template typename I::difference_type operator - (I &x, I &y) { return x.p - y.p; }$/;" f +operator - testsuite/libgomp.c++/taskloop-9.C /^template typename I::difference_type operator - (const I &x, const I &y) { return x.p - y.p; }$/;" f +operator -- testsuite/libgomp.c++/collapse-2.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/collapse-2.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/doacross-1.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/doacross-1.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/for-1.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/for-1.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/for-5.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/for-5.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/for-8.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/for-8.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/member-5.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/member-5.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/taskloop-6.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/taskloop-6.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -- testsuite/libgomp.c++/taskloop-9.C /^template I &I::operator -- () { --p; return *this; }$/;" f class:I +operator -- testsuite/libgomp.c++/taskloop-9.C /^template I I::operator -- (int) { return I (p--); }$/;" f class:I +operator -= testsuite/libgomp.c++/collapse-2.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/doacross-1.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/for-1.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/for-5.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/for-8.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/member-5.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/taskloop-6.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -= testsuite/libgomp.c++/taskloop-9.C /^template I &I::operator -= (const difference_type &x) { p -= x; return *this; }$/;" f class:I +operator -> testsuite/libgomp.c++/collapse-2.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/doacross-1.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/for-1.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/for-5.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/for-8.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/member-5.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/taskloop-6.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator -> testsuite/libgomp.c++/taskloop-9.C /^template T *I::operator -> () { return p; }$/;" f class:I +operator < testsuite/libgomp.c++/collapse-2.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/collapse-2.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/doacross-1.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/doacross-1.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-1.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-1.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-5.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-5.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-8.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/for-8.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/member-5.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/member-5.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/taskloop-6.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/taskloop-6.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/taskloop-9.C /^template bool operator < (I &x, I &y) { return x.p < y.p; }$/;" f +operator < testsuite/libgomp.c++/taskloop-9.C /^template bool operator < (const I &x, const I &y) { return x.p < y.p; }$/;" f +operator <= testsuite/libgomp.c++/collapse-2.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/collapse-2.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/doacross-1.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/doacross-1.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-1.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-1.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-5.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-5.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-8.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/for-8.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/member-5.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/member-5.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/taskloop-6.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/taskloop-6.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/taskloop-9.C /^template bool operator <= (I &x, I &y) { return x.p <= y.p; }$/;" f +operator <= testsuite/libgomp.c++/taskloop-9.C /^template bool operator <= (const I &x, const I &y) { return x.p <= y.p; }$/;" f +operator = testsuite/libgomp.c++/collapse-2.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/ctor-12.C /^ virtual A& operator= (const A &x)$/;" f struct:A +operator = testsuite/libgomp.c++/ctor-13.C /^B& B::operator=(const B &)$/;" f class:B +operator = testsuite/libgomp.c++/ctor-3.C /^B& B::operator= (const B &b)$/;" f class:B +operator = testsuite/libgomp.c++/ctor-4.C /^B& B::operator= (const B &b)$/;" f class:B +operator = testsuite/libgomp.c++/ctor-5.C /^B& B::operator= (const B &b)$/;" f class:B +operator = testsuite/libgomp.c++/ctor-6.C /^B& B::operator= (const B &b)$/;" f class:B +operator = testsuite/libgomp.c++/ctor-9.C /^B& B::operator= (const B &b)$/;" f class:B +operator = testsuite/libgomp.c++/doacross-1.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/for-1.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/for-5.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/for-8.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/member-5.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/pr26943.C /^S::operator= (const S& s)$/;" f class:S +operator = testsuite/libgomp.c++/simd-1.C /^ V &operator= (const V &x) { v = x.v + 1; return *this; }$/;" f struct:V +operator = testsuite/libgomp.c++/taskloop-6.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator = testsuite/libgomp.c++/taskloop-9.C /^template I &I::operator = (const I &x) { p = x.p; return *this; }$/;" f class:I +operator == testsuite/libgomp.c++/collapse-2.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/collapse-2.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/doacross-1.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/doacross-1.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-1.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-1.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-5.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-5.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-8.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/for-8.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/member-5.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/member-5.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/taskloop-6.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/taskloop-6.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/taskloop-9.C /^template bool operator == (I &x, I &y) { return x.p == y.p; }$/;" f +operator == testsuite/libgomp.c++/taskloop-9.C /^template bool operator == (const I &x, const I &y) { return x.p == y.p; }$/;" f +operator > testsuite/libgomp.c++/collapse-2.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/collapse-2.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/doacross-1.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/doacross-1.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-1.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-1.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-5.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-5.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-8.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/for-8.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/member-5.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/member-5.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/taskloop-6.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/taskloop-6.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/taskloop-9.C /^template bool operator > (I &x, I &y) { return x.p > y.p; }$/;" f +operator > testsuite/libgomp.c++/taskloop-9.C /^template bool operator > (const I &x, const I &y) { return x.p > y.p; }$/;" f +operator >= testsuite/libgomp.c++/collapse-2.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/collapse-2.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/doacross-1.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/doacross-1.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-1.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-1.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-5.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-5.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-8.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/for-8.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/member-5.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/member-5.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/taskloop-6.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/taskloop-6.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/taskloop-9.C /^template bool operator >= (I &x, I &y) { return x.p >= y.p; }$/;" f +operator >= testsuite/libgomp.c++/taskloop-9.C /^template bool operator >= (const I &x, const I &y) { return x.p >= y.p; }$/;" f +operator T * testsuite/libgomp.c++/pr56217.C /^ operator T * () { return p; }$/;" f struct:ptr +operator [] testsuite/libgomp.c++/collapse-2.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/doacross-1.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/for-1.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/for-5.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/for-8.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/member-5.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/taskloop-6.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +operator [] testsuite/libgomp.c++/taskloop-9.C /^template T &I::operator [] (const difference_type &x) const { return p[x]; }$/;" f class:I +ord plugin/plugin-nvptx.c /^ int ord;$/;" m struct:ptx_device file: +ord plugin/plugin-nvptx.c /^ int ord;$/;" m struct:ptx_event file: +ordered_cur libgomp.h /^ unsigned ordered_cur;$/;" m struct:gomp_work_share +ordered_num_used libgomp.h /^ unsigned ordered_num_used;$/;" m struct:gomp_work_share +ordered_owner libgomp.h /^ unsigned ordered_owner;$/;" m struct:gomp_work_share +ordered_release libgomp.h /^ gomp_sem_t **ordered_release;$/;" m struct:gomp_team +ordered_team_ids libgomp.h /^ unsigned *ordered_team_ids;$/;" m union:gomp_work_share::__anon49 +orig_getaffinity_np testsuite/libgomp.c/affinity-1.c /^int (*orig_getaffinity_np) (pthread_t, size_t, cpu_set_t *);$/;" v +orit testsuite/libgomp.c++/reduction-10.C /^orit (T *x, T *y)$/;" f +orit testsuite/libgomp.c++/reduction-12.C /^orit (T *x, T *y)$/;" f +orit testsuite/libgomp.c++/reduction-6.C /^orit (T *x, T *y)$/;" f +orit testsuite/libgomp.c++/reduction-8.C /^orit (T *x, T *y)$/;" f +orit testsuite/libgomp.c/reduction-10.c /^orit (struct C *x, struct C *y)$/;" f +orit testsuite/libgomp.c/reduction-12.c /^orit (struct C *x, struct C *y)$/;" f +orit testsuite/libgomp.c/reduction-14.c /^orit (struct C *x, struct C *y)$/;" f +orit testsuite/libgomp.c/reduction-8.c /^orit (struct C *x, struct C *y)$/;" f +outdep testsuite/libgomp.c/depend-1.c /^outdep (void)$/;" f +outdep testsuite/libgomp.fortran/depend-1.f90 /^ subroutine outdep$/;" s +output testsuite/libgomp.hsa.c/pr69568.c /^float2 *output;$/;" v +overlap plugin/plugin-nvptx.c /^ bool overlap;$/;" m struct:ptx_device file: +owner config/linux/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon40 +owner config/linux/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" m struct:__anon41 +owner config/nvptx/omp-lock.h /^typedef struct { int lock, count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon36 +owner config/nvptx/omp-lock.h /^typedef struct { int owner, count; } omp_nest_lock_25_t;$/;" m struct:__anon37 +owner config/posix/omp-lock.h /^typedef struct { pthread_mutex_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon31 +owner config/posix/omp-lock.h /^typedef struct { sem_t lock; int count; void *owner; } omp_nest_lock_t;$/;" m struct:__anon32 +p testsuite/libgomp.c++/collapse-2.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/doacross-1.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/for-1.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/for-5.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/for-6.C /^const char *p = "abcdefghij";$/;" v +p testsuite/libgomp.c++/for-7.C /^const char *p = "abcdefghij";$/;" v +p testsuite/libgomp.c++/for-8.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/member-5.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/pr56217.C /^ T *p;$/;" m struct:ptr file: +p testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +p testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +p testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +p testsuite/libgomp.c++/taskloop-6.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c++/taskloop-9.C /^ T *p;$/;" m class:I file: +p testsuite/libgomp.c/appendix-a/a.19.1.c /^int x, *p = &x;$/;" v +p testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +p testsuite/libgomp.fortran/allocatable11.f90 /^ integer :: p$/;" v +p testsuite/libgomp.fortran/crayptr1.f90 /^ integer :: a, b, c, p$/;" v +p testsuite/libgomp.fortran/crayptr2.f90 /^ integer :: a, b, c, d, p$/;" v +p testsuite/libgomp.fortran/crayptr3.f90 /^ integer :: a, b, c, i, p$/;" v +p testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^ real :: p(/;" v program:e_55_2 +p testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^ real :: p(/;" v module:e_53_3_mod +p testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ real, po/;" v program:e_51_4 +p testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ real, allocatable, dimension(:) :: p,/;" v program:e_51_5 +p testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ real, po/;" v program:e_52_1 +p testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ real, po/;" v program:e_52_2 +p testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ real, po/;" v program:e_54_5 +p testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ real, po/;" v program:e_54_6 +p testsuite/libgomp.fortran/simd1.f90 /^ integer, po/;" v +p testsuite/libgomp.fortran/target1.f90 /^ double pr/;" v +p testsuite/libgomp.fortran/target6.f90 /^ double pr/;" v +p testsuite/libgomp.fortran/udr11.f90 /^ type/;" v +p1 testsuite/libgomp.c/examples-4/declare_target-3.c /^float p1[N], p2[N], v1[N], v2[N];$/;" v +p1 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ real, pointer, dimension(:) :: p1,/;" v program:e_50_4 +p1 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1,/;" v program:collapse3 +p2 testsuite/libgomp.c/examples-4/declare_target-3.c /^float p1[N], p2[N], v1[N], v2[N];$/;" v +p2 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ real, pointer, dimension(:) :: p1, p2,/;" v program:e_50_4 +p2 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2,/;" v program:collapse3 +p3 testsuite/libgomp.c++/reduction-10.C /^A (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.c++/reduction-11.C /^int (*p3)[3][2] = &a3[2];$/;" v +p3 testsuite/libgomp.c++/reduction-12.C /^A (*p3)[3][2] = &a3[2];$/;" v +p3 testsuite/libgomp.c++/reduction-5.C /^int (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.c++/reduction-6.C /^A (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.c++/reduction-7.C /^int (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.c++/reduction-8.C /^A (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.c++/reduction-9.C /^int (*p3)[3][2] = &a3[1];$/;" v +p3 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3,/;" v program:collapse3 +p4 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4,/;" v program:collapse3 +p5 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4, p5,/;" v program:collapse3 +p6 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4, p5, p6,/;" v program:collapse3 +p7 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4, p5, p6, p7,/;" v program:collapse3 +p8 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4, p5, p6, p7, p8,/;" v program:collapse3 +p9 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ integer :: p1, p2, p3, p4, p5, p6, p7, p8, p9$/;" v program:collapse3 +packet_store_release plugin/plugin-hsa.c /^packet_store_release (uint32_t* packet, uint16_t header, uint16_t rest)$/;" f +pair testsuite/libgomp.c/appendix-a/a.40.1.c /^} pair;$/;" t typeref:struct:__anon28 file: +parallel testsuite/libgomp.c++/shared-1.C /^parallel (int a, int b)$/;" f +parallel testsuite/libgomp.c++/shared-2.C /^parallel (int a, int b)$/;" f +parallel testsuite/libgomp.c/shared-1.c /^parallel (int a, int b)$/;" f +parallel testsuite/libgomp.c/shared-2.c /^parallel (int a, int b)$/;" f +parallel testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^subroutine parallel /;" s +parallel_g_1 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void parallel_g_1()$/;" f +parallel_g_2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^void parallel_g_2()$/;" f +parent libgomp.h /^ struct gomp_task *parent;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_task +parent libgomp.h /^ struct gomp_task *parent;$/;" m struct:gomp_tdg_task typeref:struct:gomp_tdg_task::gomp_task +parent_depends_on libgomp.h /^ bool parent_depends_on;$/;" m struct:gomp_task +parent_depends_on libgomp.h /^ bool parent_depends_on;$/;" m struct:gomp_tdg_task +parloop testsuite/libgomp.c++/loop-2.C /^void parloop (int *a)$/;" f +parloop testsuite/libgomp.c/omp-loop02.c /^void parloop (int *a)$/;" f +parloop testsuite/libgomp.c/uns-outer-4.c /^parloop (int N)$/;" f +parloop testsuite/libgomp.graphite/force-parallel-1.c /^void parloop (int N)$/;" f +parloop testsuite/libgomp.graphite/force-parallel-2.c /^void parloop (int N)$/;" f +parse_acc_device_type env.c /^parse_acc_device_type (void)$/;" f file: +parse_affinity env.c /^parse_affinity (bool ignore)$/;" f file: +parse_bind_var env.c /^parse_bind_var (const char *name, char *p1stvalue,$/;" f file: +parse_boolean env.c /^parse_boolean (const char *name, bool *value)$/;" f file: +parse_int env.c /^parse_int (const char *name, int *pvalue, bool allow_zero)$/;" f file: +parse_one_place env.c /^parse_one_place (char **envp, bool *negatep, unsigned long *lenp,$/;" f file: +parse_places_var env.c /^parse_places_var (const char *name, bool ignore)$/;" f file: +parse_schedule env.c /^parse_schedule (void)$/;" f file: +parse_spincount env.c /^parse_spincount (const char *name, unsigned long long *pvalue)$/;" f file: +parse_stacksize env.c /^parse_stacksize (const char *name, unsigned long *pvalue)$/;" f file: +parse_target_attributes plugin/plugin-hsa.c /^parse_target_attributes (void **input,$/;" f file: +parse_tdg env.c /^parse_tdg (void)$/;" f file: +parse_thread_pools config/rtems/proc.c /^parse_thread_pools (char *env, unsigned long *count, unsigned long *priority,$/;" f file: +parse_unsigned_long env.c /^parse_unsigned_long (const char *name, unsigned long *pvalue, bool allow_zero)$/;" f file: +parse_unsigned_long_list env.c /^parse_unsigned_long_list (const char *name, unsigned long *p1stvalue,$/;" f file: +parse_wait_policy env.c /^parse_wait_policy (void)$/;" f file: +partition testsuite/libgomp.c/sort-1.c /^partition (int *array, int lo, int hi)$/;" f file: +pipedF testsuite/libgomp.c/examples-4/async_target-1.c /^void pipedF ()$/;" f +pipedF testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^subroutine pipedF /;" s +pipedF_ref testsuite/libgomp.c/examples-4/async_target-1.c /^void pipedF_ref ()$/;" f +pipedF_ref testsuite/libgomp.fortran/examples-4/async_target-1.f90 /^subroutine pipedF_ref /;" s +place libgomp.h /^ unsigned int place;$/;" m struct:gomp_thread +place team.c /^ unsigned int place;$/;" m struct:gomp_thread_start_data file: +place testsuite/libgomp.c/affinity-1.c /^struct place$/;" s file: +place testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^static int __attribute__((noinline)) place ()$/;" f file: +place testsuite/libgomp.oacc-c-c++-common/tile-1.c /^static int __attribute__((noinline)) place ()$/;" f file: +place_partition_len libgomp.h /^ unsigned place_partition_len;$/;" m struct:gomp_team_state +place_partition_off libgomp.h /^ unsigned place_partition_off;$/;" m struct:gomp_team_state +places testsuite/libgomp.c/affinity-1.c /^ struct place places[8];$/;" m struct:places typeref:struct:places::place file: +places testsuite/libgomp.c/affinity-1.c /^struct places$/;" s file: +places_array testsuite/libgomp.c/affinity-1.c /^} places_array[] = {$/;" v typeref:struct:places +pnode libgomp.h /^ struct priority_node pnode[2];$/;" m struct:gomp_tdg_task typeref:struct:gomp_tdg_task::priority_node +pnode libgomp.h /^ struct priority_node pnode[3];$/;" m struct:gomp_task typeref:struct:gomp_task::priority_node +pools config/rtems/pool.h /^ struct gomp_thread_pool *pools[];$/;" m struct:gomp_thread_pool_reservoir typeref:struct:gomp_thread_pool_reservoir::gomp_thread_pool +pop_int_pair_stack testsuite/libgomp.c/sort-1.c /^pop_int_pair_stack (struct int_pair_stack *stack, int *lo, int *hi)$/;" f file: +pr27395_1 testsuite/libgomp.fortran/pr27395-1.f90 /^program pr27395_1$/;" p +pr27395_2 testsuite/libgomp.fortran/pr27395-2.f90 /^program pr27395_2$/;" p +pr27916 testsuite/libgomp.fortran/pr27916-1.f90 /^program pr27916$/;" p +pr27916 testsuite/libgomp.fortran/pr27916-2.f90 /^program pr27916$/;" p +pr28390 testsuite/libgomp.fortran/pr28390.f /^ program pr28390$/;" p +pr29629 testsuite/libgomp.fortran/pr29629.f90 /^program pr29629$/;" p +pr33880 testsuite/libgomp.fortran/pr33880.f90 /^program pr33880$/;" p +pr35130 testsuite/libgomp.fortran/pr35130.f90 /^program pr35130$/;" p +pr42162 testsuite/libgomp.fortran/pr42162.f90 /^program pr42162$/;" p +pr42866 testsuite/libgomp.fortran/allocatable5.f90 /^program pr42866$/;" p +pr49792 testsuite/libgomp.fortran/pr49792-1.f90 /^program pr49792$/;" p +pr49792 testsuite/libgomp.fortran/pr49792-2.f90 /^program pr49792$/;" p +pr63938_1 testsuite/libgomp.fortran/pr63938-1.f90 /^program pr63938_1$/;" p +pr63938_2 testsuite/libgomp.fortran/pr63938-2.f90 /^program pr63938_2$/;" p +pr71014 testsuite/libgomp.fortran/pr71014.f90 /^program pr71014$/;" p +pr81304 testsuite/libgomp.fortran/pr81304.f90 /^program pr81304$/;" p +pr81841 testsuite/libgomp.fortran/pr81841.f90 /^program pr81841$/;" p +pragma_id tdg.h /^ unsigned int pragma_id; \/\/ Identifier of the task contruct from which this task instance has been created$/;" m struct:gomp_tdg_node +present_create_copy oacc-mem.c /^present_create_copy (unsigned f, void *h, size_t s)$/;" f file: +prev libgomp.h /^ struct gomp_task_depend_entry *prev;$/;" m struct:gomp_task_depend_entry typeref:struct:gomp_task_depend_entry::gomp_task_depend_entry +prev libgomp.h /^ struct gomp_taskgroup *prev;$/;" m struct:gomp_taskgroup typeref:struct:gomp_taskgroup::gomp_taskgroup +prev libgomp.h /^ struct target_mem_desc *prev;$/;" m struct:target_mem_desc typeref:struct:target_mem_desc::target_mem_desc +prev plugin/plugin-hsa.c /^ struct module_info *next, *prev;$/;" m struct:module_info typeref:struct:module_info:: file: +prev priority_queue.h /^ struct priority_node *next, *prev;$/;" m struct:priority_node typeref:struct:priority_node:: +prev tdg.c /^struct data_to_free *prev = NULL;$/;" v typeref:struct:data_to_free +prev_ts libgomp.h /^ struct gomp_team_state prev_ts;$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_team_state +pri testsuite/libgomp.fortran/examples-4/simd-8.f90 /^ real :: pri,/;" v program:simd_8f +prime hashtab.h /^ hashval_t prime;$/;" m struct:prime_ent +prime_ent hashtab.h /^struct prime_ent$/;" s +prime_tab hashtab.h /^static struct prime_ent const prime_tab[] = {$/;" v +print_affinity testsuite/libgomp.c/affinity-1.c /^print_affinity (struct place p)$/;" f +print_kernel_dispatch plugin/plugin-hsa.c /^print_kernel_dispatch (struct GOMP_hsa_kernel_dispatch *dispatch, unsigned indent)$/;" f file: +print_partition testsuite/libgomp.fortran/affinity1.f90 /^ subroutine print_partition /;" s +print_place testsuite/libgomp.c/affinity-2.c /^print_place (int count, int *ids)$/;" f +print_place testsuite/libgomp.fortran/affinity1.f90 /^ subroutine print_place /;" s +print_place_var testsuite/libgomp.c/affinity-2.c /^print_place_var (void)$/;" f +print_place_var testsuite/libgomp.fortran/affinity1.f90 /^ subroutine print_place_var$/;" s +prio_splay_compare priority_queue.c /^prio_splay_compare (prio_splay_tree_key x, prio_splay_tree_key y)$/;" f file: +prio_splay_tree priority_queue.h /^typedef struct prio_splay_tree_s *prio_splay_tree;$/;" t typeref:struct:prio_splay_tree_s +prio_splay_tree_key priority_queue.h /^typedef struct prio_splay_tree_key_s *prio_splay_tree_key;$/;" t typeref:struct:prio_splay_tree_key_s +prio_splay_tree_key_s priority_queue.h /^struct prio_splay_tree_key_s {$/;" s +prio_splay_tree_node priority_queue.h /^typedef struct prio_splay_tree_node_s *prio_splay_tree_node;$/;" t typeref:struct:prio_splay_tree_node_s +priority config/rtems/pool.h /^ int priority;$/;" m struct:gomp_thread_pool_reservoir +priority libgomp.h /^ int priority;$/;" m struct:gomp_task +priority libgomp.h /^ int priority;$/;" m struct:gomp_tdg_task +priority priority_queue.h /^ int priority;$/;" m struct:priority_list +priority_insert_type priority_queue.h /^enum priority_insert_type {$/;" g +priority_list priority_queue.h /^struct priority_list$/;" s +priority_list_downgrade_task task.c /^priority_list_downgrade_task (enum priority_queue_type type,$/;" f file: +priority_list_insert priority_queue.h /^priority_list_insert (enum priority_queue_type type,$/;" f +priority_list_remove priority_queue.h /^priority_list_remove (struct priority_list *list,$/;" f +priority_list_tdg_remove priority_queue.h /^priority_list_tdg_remove (struct priority_list *list,$/;" f +priority_list_upgrade_task task.c /^priority_list_upgrade_task (struct priority_list *list,$/;" f file: +priority_list_verify priority_queue.c /^priority_list_verify (enum priority_queue_type type,$/;" f file: +priority_node priority_queue.h /^struct priority_node$/;" s +priority_node_to_task libgomp.h /^priority_node_to_task (enum priority_queue_type type,$/;" f +priority_node_to_tdg_task libgomp.h /^priority_node_to_tdg_task (enum priority_queue_type type,$/;" f +priority_queue priority_queue.h /^struct priority_queue$/;" s +priority_queue_downgrade_task task.c /^priority_queue_downgrade_task (enum priority_queue_type type,$/;" f file: +priority_queue_empty_p priority_queue.h /^priority_queue_empty_p (struct priority_queue *head, enum memmodel model)$/;" f +priority_queue_free priority_queue.h /^priority_queue_free (struct priority_queue *head)$/;" f +priority_queue_gen_insert libgomp.h /^static inline void priority_queue_gen_insert (enum priority_queue_type type,$/;" f +priority_queue_init priority_queue.h /^priority_queue_init (struct priority_queue *head)$/;" f +priority_queue_insert priority_queue.h /^priority_queue_insert (enum priority_queue_type type,$/;" f +priority_queue_lookup_priority priority_queue.h /^priority_queue_lookup_priority (struct priority_queue *head, int priority)$/;" f +priority_queue_move_task_first task.c /^priority_queue_move_task_first (enum priority_queue_type type,$/;" f file: +priority_queue_multi_p priority_queue.h /^priority_queue_multi_p (struct priority_queue *head)$/;" f +priority_queue_next_gen_task libgomp.h /^priority_queue_next_gen_task (enum priority_queue_type t1,$/;" f +priority_queue_next_task priority_queue.h /^priority_queue_next_task (enum priority_queue_type t1,$/;" f +priority_queue_offset libgomp.h /^priority_queue_offset (enum priority_queue_type type)$/;" f +priority_queue_remove priority_queue.h /^priority_queue_remove (enum priority_queue_type type,$/;" f +priority_queue_task_in_list_p priority_queue.c /^priority_queue_task_in_list_p (enum priority_queue_type type,$/;" f file: +priority_queue_task_in_queue_p priority_queue.c /^priority_queue_task_in_queue_p (enum priority_queue_type type,$/;" f +priority_queue_task_in_tree_p priority_queue.c /^priority_queue_task_in_tree_p (enum priority_queue_type type,$/;" f file: +priority_queue_tdg_offset libgomp.h /^priority_queue_tdg_offset (enum priority_queue_type type)$/;" f +priority_queue_tdg_remove priority_queue.h /^priority_queue_tdg_remove (enum priority_queue_type type,$/;" f +priority_queue_type priority_queue.h /^enum priority_queue_type$/;" g +priority_queue_upgrade_task task.c /^priority_queue_upgrade_task (struct gomp_task *task,$/;" f file: +priority_queue_verify priority_queue.c /^priority_queue_verify (enum priority_queue_type type,$/;" f +priority_tree_insert priority_queue.h /^priority_tree_insert (enum priority_queue_type type,$/;" f +priority_tree_next_task priority_queue.c /^priority_tree_next_task (enum priority_queue_type type1,$/;" f +priority_tree_next_task_1 priority_queue.c /^priority_tree_next_task_1 (enum priority_queue_type type,$/;" f file: +priority_tree_remove priority_queue.c /^priority_tree_remove (enum priority_queue_type type,$/;" f +priority_tree_tdg_remove priority_queue.c /^priority_tree_tdg_remove (enum priority_queue_type type,$/;" f +priority_tree_verify_callback priority_queue.c /^priority_tree_verify_callback (prio_splay_tree_key key, void *data)$/;" f file: +private_segment_size plugin/plugin-hsa.c /^ uint32_t private_segment_size;$/;" m struct:GOMP_hsa_kernel_dispatch file: +private_segment_size plugin/plugin-hsa.c /^ uint32_t private_segment_size;$/;" m struct:kernel_info file: +prog_finalized plugin/plugin-hsa.c /^ bool prog_finalized;$/;" m struct:agent_info file: +prog_finalized_error plugin/plugin-hsa.c /^ bool prog_finalized_error;$/;" m struct:agent_info file: +prog_mutex plugin/plugin-hsa.c /^ pthread_mutex_t prog_mutex;$/;" m struct:agent_info file: +prototypes configure /^ function prototypes and stuff, but not '\\xHH' hex character constants.$/;" f +pthread_getaffinity_np testsuite/libgomp.c/affinity-1.c /^pthread_getaffinity_np (pthread_t thread, size_t cpusetsize, cpu_set_t *cpuset)$/;" f +ptr config/posix/ptrlock.h /^typedef struct { void *ptr; gomp_mutex_t lock; } gomp_ptrlock_t;$/;" m struct:__anon34 +ptr testsuite/libgomp.c++/pr56217.C /^ ptr () : p () {}$/;" f struct:ptr +ptr testsuite/libgomp.c++/pr56217.C /^ ptr (ptr &&o) : p(o) {}$/;" f struct:ptr +ptr testsuite/libgomp.c++/pr56217.C /^struct ptr {$/;" s file: +ptr testsuite/libgomp.fortran/pr32550.f90 /^ integer, pointer, save :: ptr$/;" v +ptrdiff_t testsuite/libgomp.c++/collapse-2.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/doacross-1.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/for-1.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/for-5.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/for-8.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/member-5.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/taskloop-6.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptrdiff_t testsuite/libgomp.c++/taskloop-9.C /^typedef __PTRDIFF_TYPE__ ptrdiff_t;$/;" t file: +ptx_dev plugin/plugin-nvptx.c /^ struct ptx_device *ptx_dev;$/;" m struct:nvptx_thread typeref:struct:nvptx_thread::ptx_device file: +ptx_dev_lock plugin/plugin-nvptx.c /^static pthread_mutex_t ptx_dev_lock = PTHREAD_MUTEX_INITIALIZER;$/;" v file: +ptx_device plugin/plugin-nvptx.c /^struct ptx_device$/;" s file: +ptx_devices plugin/plugin-nvptx.c /^static struct ptx_device **ptx_devices;$/;" v typeref:struct:ptx_device file: +ptx_event plugin/plugin-nvptx.c /^struct ptx_event$/;" s file: +ptx_event_lock plugin/plugin-nvptx.c /^static pthread_mutex_t ptx_event_lock;$/;" v file: +ptx_event_type plugin/plugin-nvptx.c /^enum ptx_event_type$/;" g file: +ptx_events plugin/plugin-nvptx.c /^static struct ptx_event *ptx_events;$/;" v typeref:struct:ptx_event file: +ptx_image_data plugin/plugin-nvptx.c /^struct ptx_image_data$/;" s file: +ptx_num plugin/plugin-nvptx.c /^ unsigned ptx_num;$/;" m struct:nvptx_tdata file: +ptx_objs plugin/plugin-nvptx.c /^ const struct targ_ptx_obj *ptx_objs;$/;" m struct:nvptx_tdata typeref:struct:nvptx_tdata::targ_ptx_obj file: +ptx_stream plugin/plugin-nvptx.c /^struct ptx_stream$/;" s file: +push_int_pair_stack testsuite/libgomp.c/sort-1.c /^push_int_pair_stack (struct int_pair_stack *stack, int lo, int hi)$/;" f file: +q libgomp.h /^ long q;$/;" m union:gomp_doacross_work_share::__anon44 +q testsuite/libgomp.c++/target-15.C /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; unsigned char &e; char (&f)[2]; short (&g)[4]; int *&h; char q[64]; };$/;" m struct:S file: +q testsuite/libgomp.c++/target-16.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UC &e; C (&f)[2]; SH (&g)[4]; I *&h; C q[64]; };$/;" m struct:S file: +q testsuite/libgomp.c++/target-17.C /^struct S { C p[64]; I a; I b[2]; L c[4]; I *d; UCR e; CAR f; SH g; IPR h; C q[64]; };$/;" m struct:S file: +q testsuite/libgomp.c/pr36802-2.c /^int q;$/;" v +q testsuite/libgomp.c/pr36802-3.c /^int q;$/;" v +q testsuite/libgomp.c/target-29.c /^struct S { char p[64]; int a; int b[2]; long c[4]; int *d; char q[64]; };$/;" m struct:S file: +q testsuite/libgomp.c/taskloop-1.c /^int q, r, e;$/;" v +q testsuite/libgomp.fortran/nestedfn5.f90 /^ integer :: q(/;" v +q testsuite/libgomp.fortran/simd1.f90 /^ integer, target :: q(/;" v +q testsuite/libgomp.fortran/target2.f90 /^ integer, parameter :: n = 15, q /;" v +q testsuite/libgomp.fortran/taskloop1.f90 /^ integer :: q,/;" v +q testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n, o, p, q,/;" v +q_ull libgomp.h /^ unsigned long long q_ull;$/;" m union:gomp_doacross_work_share::__anon44 +queue plugin/plugin-hsa.c /^ void *queue;$/;" m struct:GOMP_hsa_kernel_dispatch file: +queue_callback plugin/plugin-hsa.c /^queue_callback (hsa_status_t status,$/;" f file: +r testsuite/libgomp.c++/member-1.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-2.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-3.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-4.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-5.C /^struct R { R () {}; ~R () {}; I r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-6.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/member-7.C /^struct R { R () {}; ~R () {}; int r; };$/;" m struct:R file: +r testsuite/libgomp.c++/target-19.C /^struct S { char a[64]; int (&r)[2]; char b[64]; };$/;" m struct:S file: +r testsuite/libgomp.c/taskloop-1.c /^int q, r, e;$/;" v +r testsuite/libgomp.fortran/omp_atomic2.f90 /^ re/;" v +r testsuite/libgomp.fortran/pr27916-1.f90 /^ logical :: r$/;" v program:pr27916 +r testsuite/libgomp.fortran/pr27916-2.f90 /^ logical :: r$/;" v program:pr27916 +r testsuite/libgomp.fortran/reduction1.f90 /^ re/;" v +r testsuite/libgomp.fortran/reduction3.f90 /^ re/;" v +r testsuite/libgomp.fortran/simd1.f90 /^ integer /;" v +r testsuite/libgomp.fortran/target5.f90 /^ integer /;" v +r testsuite/libgomp.fortran/taskloop1.f90 /^ integer /;" v +r testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n, o, p, q, r,/;" v +r testsuite/libgomp.fortran/udr12.f90 /^ integer /;" v +r testsuite/libgomp.fortran/udr13.f90 /^ integer /;" v +r testsuite/libgomp.fortran/udr14.f90 /^ integer /;" v +r testsuite/libgomp.fortran/udr5.f90 /^ re/;" k type:dt +r testsuite/libgomp.fortran/udr5.f90 /^ re/;" v program:udr5 +r testsuite/libgomp.fortran/udr6.f90 /^ re/;" k type:dt +r testsuite/libgomp.fortran/udr6.f90 /^ re/;" v program:udr6 +r testsuite/libgomp.oacc-fortran/collapse-4.f90 /^ logical :: l, r$/;" v program:collapse4 +r testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ logical :: l, r$/;" v program:collapse5 +r testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ logical :: l, r$/;" v program:collapse6 +r testsuite/libgomp.oacc-fortran/collapse-7.f90 /^ logical :: l, r$/;" v program:collapse7 +r testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ logical :: l, r$/;" v program:collapse8 +r testsuite/libgomp.oacc-fortran/lib-10.f90 /^ re/;" v program:main +r testsuite/libgomp.oacc-fortran/lib-8.f90 /^ re/;" v program:main +r4 testsuite/libgomp.fortran/udr5.f90 /^ real (kind = 4) :: r4$/;" v program:udr5 +r4 testsuite/libgomp.fortran/udr6.f90 /^ real (kind = 4), allocatable :: r4(/;" v program:udr6 +r_size testsuite/libgomp.oacc-fortran/lib-10.f90 /^ integer, parameter :: r_size /;" v program:main +r_size testsuite/libgomp.oacc-fortran/lib-8.f90 /^ integer, parameter :: r_size /;" v program:main +ra testsuite/libgomp.fortran/reduction1.f90 /^ real :: r, ra /;" v +ra testsuite/libgomp.fortran/reduction3.f90 /^ real :: r, ra /;" v +range plugin/hsa_ext_finalize.h /^ hsa_dim3_t range;$/;" m struct:hsa_ext_image_region_s +rc testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer :: i, vresult, rg, rw, rv, rc$/;" v program:reduction_1 +rc testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real :: vresult, rg, rw, rv, rc$/;" v program:reduction_2 +rc testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision :: vresult, rg, rw, rv, rc$/;" v program:reduction_3 +rc testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ real :: vresult, rg, rw, rv, rc$/;" v program:reduction_4 +record_g tdg.c /^bool record_g = false;$/;" v +recursive testsuite/libgomp.fortran/examples-4/declare_target-2.f90 /^integer recursive /;" v +red testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: j, red,/;" v program:reduction +redsub testsuite/libgomp.oacc-fortran/parallel-reduction.f90 /^subroutine redsub(/;" s +redsub_bogus testsuite/libgomp.oacc-fortran/reduction-7.f90 /^subroutine redsub_bogus(/;" s +redsub_combined testsuite/libgomp.oacc-fortran/reduction-5.f90 /^subroutine redsub_combined(/;" s +redsub_combined testsuite/libgomp.oacc-fortran/reduction-7.f90 /^subroutine redsub_combined(/;" s +redsub_gang testsuite/libgomp.oacc-fortran/reduction-5.f90 /^subroutine redsub_gang(/;" s +redsub_nested testsuite/libgomp.oacc-fortran/reduction-5.f90 /^subroutine redsub_nested(/;" s +redsub_private testsuite/libgomp.oacc-fortran/reduction-7.f90 /^subroutine redsub_private(/;" s +redsub_vector testsuite/libgomp.oacc-fortran/reduction-5.f90 /^subroutine redsub_vector(/;" s +redsub_worker testsuite/libgomp.oacc-fortran/reduction-5.f90 /^subroutine redsub_worker(/;" s +reduction testsuite/libgomp.oacc-fortran/parallel-reduction.f90 /^program reduction$/;" p +reduction testsuite/libgomp.oacc-fortran/reduction-5.f90 /^program reduction$/;" p +reduction testsuite/libgomp.oacc-fortran/reduction-6.f90 /^program reduction$/;" p +reduction testsuite/libgomp.oacc-fortran/reduction-7.f90 /^program reduction$/;" p +reduction testsuite/libgomp.oacc-fortran/reduction-8.f90 /^program reduction$/;" p +reduction5 testsuite/libgomp.fortran/reduction5.f90 /^module reduction5$/;" m +reduction_1 testsuite/libgomp.oacc-fortran/reduction-1.f90 /^program reduction_1$/;" p +reduction_2 testsuite/libgomp.oacc-fortran/reduction-2.f90 /^program reduction_2$/;" p +reduction_3 testsuite/libgomp.oacc-fortran/reduction-3.f90 /^program reduction_3$/;" p +reduction_4 testsuite/libgomp.oacc-fortran/reduction-4.f90 /^program reduction_4$/;" p +reduction_kernel testsuite/libgomp.oacc-fortran/pr70643.f90 /^SUBROUTINE reduction_kernel(/;" s module:reduction_test +reduction_test testsuite/libgomp.oacc-fortran/pr70643.f90 /^MODULE reduction_test$/;" m +redundant libgomp.h /^ bool redundant;$/;" m struct:gomp_task_depend_entry +redundant_out libgomp.h /^ bool redundant_out;$/;" m struct:gomp_task_depend_entry +ref testsuite/libgomp.fortran/examples-4/teams-2.f90 /^ real :: ref,/;" v program:e_54_1 +ref testsuite/libgomp.fortran/examples-4/teams-3.f90 /^ real :: ref,/;" v program:e_54_3 +ref testsuite/libgomp.fortran/examples-4/teams-4.f90 /^ real :: ref,/;" v program:e_54_4 +refcount libgomp.h /^ uintptr_t refcount;$/;" m struct:splay_tree_key_s +refcount libgomp.h /^ uintptr_t refcount;$/;" m struct:target_mem_desc +register_async_cleanup_func libgomp.h /^ *register_async_cleanup_func;$/;" m struct:acc_dispatch_t +register_lock target.c /^static gomp_mutex_t register_lock;$/;" v file: +regs_per_block plugin/plugin-nvptx.c /^ int regs_per_block;$/;" m struct:ptx_device file: +regs_per_sm plugin/plugin-nvptx.c /^ int regs_per_sm;$/;" m struct:ptx_device file: +regs_per_thread plugin/plugin-nvptx.c /^ int regs_per_thread;$/;" m struct:targ_fn_descriptor file: +relax testsuite/libgomp.fortran/jacobi.f /^ double precision tol,relax,/;" v program:main +release libgomp.h /^ gomp_sem_t release;$/;" m struct:gomp_thread +release_agent_shared_libraries plugin/plugin-hsa.c /^release_agent_shared_libraries (struct agent_info *agent)$/;" f file: +release_kernel_dispatch plugin/plugin-hsa.c /^release_kernel_dispatch (struct GOMP_hsa_kernel_dispatch *shadow)$/;" f file: +remove_module_from_agent plugin/plugin-hsa.c /^remove_module_from_agent (struct agent_info *agent, struct module_info *module)$/;" f file: +required_dim plugin/hsa_ext_finalize.h /^ uint8_t required_dim;$/;" m struct:hsa_ext_control_directives_s +required_grid_size plugin/hsa_ext_finalize.h /^ uint64_t required_grid_size[3];$/;" m struct:hsa_ext_control_directives_s +required_workgroup_size plugin/hsa_ext_finalize.h /^ hsa_dim3_t required_workgroup_size;$/;" m struct:hsa_ext_control_directives_s +res testsuite/libgomp.fortran/examples-4/device-3.f90 /^ logical :: res$/;" v program:e_57_3 +res testsuite/libgomp.fortran/target4.f90 /^ double precision :: a(8, 9), res(/;" v +reserved1 plugin/hsa_ext_finalize.h /^ uint32_t reserved1;$/;" m struct:hsa_ext_control_directives_s +reserved2 plugin/hsa_ext_finalize.h /^ uint8_t reserved2[75];$/;" m struct:hsa_ext_control_directives_s +resolve_device oacc-init.c /^resolve_device (acc_device_t d, bool fail_is_error)$/;" f file: +resolve_device target.c /^resolve_device (int device_id)$/;" f file: +result testsuite/libgomp.c/appendix-a/a.18.1.c /^int result[NUMBER_OF_THREADS];$/;" v +results testsuite/libgomp.c++/collapse-2.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/doacross-1.C /^int results[2048];$/;" v +results testsuite/libgomp.c++/for-1.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/for-2.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/for-3.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/for-5.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/for-8.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/taskloop-6.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/taskloop-7.C /^int results[2000];$/;" v +results testsuite/libgomp.c++/taskloop-9.C /^int results[2000];$/;" v +ret3 testsuite/libgomp.fortran/lastprivate1.f90 /^ function ret3 /;" f program:lastprivate +ret3 testsuite/libgomp.fortran/lastprivate2.f90 /^ function ret3 /;" f program:lastprivate +reverse testsuite/libgomp.fortran/pr49792-1.f90 /^subroutine reverse(/;" s +reverse testsuite/libgomp.fortran/pr49792-2.f90 /^subroutine reverse(/;" s +rg testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer :: i, vresult, rg,/;" v program:reduction_1 +rg testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real :: vresult, rg,/;" v program:reduction_2 +rg testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision :: vresult, rg,/;" v program:reduction_3 +rg testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ real :: vresult, rg,/;" v program:reduction_4 +rhs testsuite/libgomp.fortran/pr34020.f90 /^ real lhs, rhs$/;" v +right splay-tree.h /^ splay_tree_node right;$/;" m struct:splay_tree_node_s +root splay-tree.h /^ splay_tree_node root;$/;" m struct:splay_tree_s +root_list tdg.h /^struct root_list {$/;" s +roots tdg.c /^struct root_list *roots = {0}; \/\/ the list of roots in a graph$/;" v typeref:struct:root_list +rotate testsuite/libgomp.hsa.c/rotate-1.c /^rotate (T value, T shift)$/;" f +rotate_left splay-tree.c /^rotate_left (splay_tree_node *pp, splay_tree_node p, splay_tree_node n)$/;" f file: +rotate_right splay-tree.c /^rotate_right (splay_tree_node *pp, splay_tree_node p, splay_tree_node n)$/;" f file: +rows testsuite/libgomp.fortran/examples-4/target_data-3.f90 /^ integer :: cols, rows$/;" v program:e_51_3 +run_func libgomp.h /^ __typeof (GOMP_OFFLOAD_run) *run_func;$/;" m struct:gomp_device_descr +run_kernel plugin/plugin-hsa.c /^run_kernel (struct kernel_info *kernel, void *vars,$/;" f +run_kernel_asynchronously plugin/plugin-hsa.c /^run_kernel_asynchronously (void *thread_arg)$/;" f file: +run_sched_chunk_size libgomp.h /^ int run_sched_chunk_size;$/;" m struct:gomp_task_icv +run_sched_var libgomp.h /^ enum gomp_schedule_type run_sched_var;$/;" m struct:gomp_task_icv typeref:enum:gomp_task_icv::gomp_schedule_type +runtime_counter tdg.h /^ long runtime_counter; \/\/ Private counter assigned to each task instance to compute the overhead of the runtime$/;" m struct:gomp_tdg_node +rv testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer :: i, vresult, rg, rw, rv,/;" v program:reduction_1 +rv testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real :: vresult, rg, rw, rv,/;" v program:reduction_2 +rv testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision :: vresult, rg, rw, rv,/;" v program:reduction_3 +rv testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ real :: vresult, rg, rw, rv,/;" v program:reduction_4 +rw testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer :: i, vresult, rg, rw,/;" v program:reduction_1 +rw testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real :: vresult, rg, rw,/;" v program:reduction_2 +rw testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision :: vresult, rg, rw,/;" v program:reduction_3 +rw testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ real :: vresult, rg, rw,/;" v program:reduction_4 +s testsuite/libgomp.c++/cancel-test.h /^ static int s;$/;" m struct:S +s testsuite/libgomp.c++/cancel-test.h /^int S::s = 0;$/;" m class:S +s testsuite/libgomp.c++/pr35185.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/pr81314.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/simd-4.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/simd-5.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/simd-6.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/simd-7.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/simd-8.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +s testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" m struct:S file: +s testsuite/libgomp.c++/target-12.C /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +s testsuite/libgomp.c++/target-6.C /^struct S { int s, t; };$/;" m struct:S file: +s testsuite/libgomp.c++/udr-1.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/udr-2.C /^ int s;$/;" m struct:NS::S file: +s testsuite/libgomp.c++/udr-3.C /^ int s;$/;" m struct:NS::S file: +s testsuite/libgomp.c++/udr-4.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/udr-7.C /^ int s;$/;" m struct:S file: +s testsuite/libgomp.c++/udr-8.C /^struct S { int s; S () : s (0) {} };$/;" m struct:S file: +s testsuite/libgomp.c/simd-10.c /^int s = 0, i, u;$/;" v +s testsuite/libgomp.c/simd-11.c /^int s = 0, i, j, u;$/;" v +s testsuite/libgomp.c/simd-4.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/simd-5.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/simd-6.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/simd-8.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/simd-9.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/target-13.c /^struct S { int s, t; };$/;" m struct:S file: +s testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +s testsuite/libgomp.c/target-22.c /^struct S { int *s; char *u; struct T v; short *w; };$/;" m struct:S file: +s testsuite/libgomp.c/target-23.c /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +s testsuite/libgomp.c/target-link-1.c /^struct S { int s, t; };$/;" m struct:S file: +s testsuite/libgomp.c/udr-1.c /^struct S { int s; struct S *t; };$/;" m struct:S file: +s testsuite/libgomp.c/udr-2.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.c/udr-3.c /^struct S { int s; };$/;" m struct:S file: +s testsuite/libgomp.fortran/pointer2.f90 /^ integer, target :: s(/;" v +s testsuite/libgomp.fortran/pr71014.f90 /^ integer :: s(/;" v program:pr71014 +s testsuite/libgomp.fortran/recursion1.f90 /^integer :: i,s$/;" v +s testsuite/libgomp.fortran/simd1.f90 /^ integer :: i, j, k, l, r, s,/;" v +s testsuite/libgomp.fortran/simd2.f90 /^ integer :: a(1024), b(1024), k, m, i, s,/;" v +s testsuite/libgomp.fortran/simd3.f90 /^ integer :: a(1024), b(1024), k, m, i, s,/;" v +s testsuite/libgomp.fortran/simd4.f90 /^ integer :: a(1024), b(1024), k, m, i, s,/;" v +s testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n, o, p, q, r, s,/;" v +s testsuite/libgomp.hsa.c/formal-actual-args-1.c 48;" d file: +s testsuite/libgomp.hsa.c/switch-1.c 3;" d file: +s testsuite/libgomp.hsa.c/switch-branch-1.c 3;" d file: +s testsuite/libgomp.hsa.c/switch-sbr-2.c 21;" d file: +s1 testsuite/libgomp.c++/pr66702-2.C /^struct S { int s1, s2; };$/;" m struct:S file: +s1 testsuite/libgomp.fortran/pr66680.f90 /^ pure subroutine s1(/;" s module:m1 +s1 testsuite/libgomp.fortran/udr15.f90 /^ subroutine s1 /;" s module:udr15m1 +s1 testsuite/libgomp.oacc-fortran/parallel-reduction.f90 /^ integer s1,/;" v program:reduction +s1 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1, h2, s1,/;" v program:reduction +s2 testsuite/libgomp.c++/pr66702-2.C /^struct S { int s1, s2; };$/;" m struct:S file: +s2 testsuite/libgomp.fortran/pr66680.f90 /^ pure subroutine s2(/;" s module:m2 +s2 testsuite/libgomp.oacc-fortran/parallel-reduction.f90 /^ integer s1, s2$/;" v program:reduction +s2 testsuite/libgomp.oacc-fortran/reduction-8.f90 /^ integer :: i, h1, h2, s1, s2,/;" v program:reduction +s3 testsuite/libgomp.fortran/pr66680.f90 /^ subroutine s3(/;" s module:m2 +s3 testsuite/libgomp.fortran/udr15.f90 /^ subroutine s3 /;" s module:udr15m2 +saved_bound_dev oacc-int.h /^ struct gomp_device_descr *saved_bound_dev;$/;" m struct:goacc_thread typeref:struct:goacc_thread::gomp_device_descr +saw testsuite/libgomp.c/parallel-1.c /^static int saw[4];$/;" v file: +saxpy testsuite/libgomp.oacc-c-c++-common/context-1.c /^saxpy (int n, float a, float *x, float *y)$/;" f +saxpy testsuite/libgomp.oacc-c-c++-common/context-2.c /^saxpy (int n, float a, float *x, float *y)$/;" f +saxpy testsuite/libgomp.oacc-c-c++-common/context-3.c /^saxpy (int n, float a, float *x, float *y)$/;" f +saxpy testsuite/libgomp.oacc-c-c++-common/context-4.c /^saxpy (int n, float a, float *x, float *y)$/;" f +saxpy_host testsuite/libgomp.oacc-c-c++-common/host_data-1.c /^saxpy_host (int n, float a, float *x, float *y)$/;" f +saxpy_target testsuite/libgomp.oacc-c-c++-common/host_data-1.c /^saxpy_target (int n, float a, float *x, float *y)$/;" f +sched libgomp.h /^ enum gomp_schedule_type sched;$/;" m struct:gomp_work_share typeref:enum:gomp_work_share::gomp_schedule_type +search testsuite/libgomp.c/cancel-taskgroup-1.c /^search (struct T *tree, int val, int lvl)$/;" f +searchp testsuite/libgomp.c/cancel-taskgroup-1.c /^searchp (struct T *tree, int val)$/;" f +secure_getenv plugin/plugin-hsa.c /^secure_getenv (const char *name)$/;" f file: +secure_getenv plugin/plugin-hsa.c 46;" d file: +secure_getenv plugin/plugin-hsa.c 65;" d file: +select_stream_for_async plugin/plugin-nvptx.c /^select_stream_for_async (int async, pthread_t thread, bool create,$/;" f file: +sem1 config/posix/bar.h /^ gomp_sem_t sem1;$/;" m struct:__anon35 +sem2 config/posix/bar.h /^ gomp_sem_t sem2;$/;" m struct:__anon35 +seq testsuite/libgomp.oacc-c-c++-common/routine-4.c /^seq (int *a)$/;" f +seq testsuite/libgomp.oacc-fortran/routine-7.f90 /^subroutine seq /;" s program:main +set testsuite/libgomp.c++/loop-12.C /^set (int loopidx, int idx)$/;" f +set testsuite/libgomp.c++/loop-9.C /^set (int loopidx, int idx)$/;" f +set testsuite/libgomp.c/loop-12.c /^set (int loopidx, int idx)$/;" f +set testsuite/libgomp.c/loop-6.c /^set (int loopidx, int idx)$/;" f +set3d testsuite/libgomp.oacc-fortran/lib-10.f90 /^ subroutine set3d /;" s program:main +set3d testsuite/libgomp.oacc-fortran/lib-8.f90 /^ subroutine set3d /;" s program:main +set_data testsuite/libgomp.c/loop-1.c /^static void set_data (long i, int val)$/;" f file: +set_data testsuite/libgomp.c/loop-2.c /^static void set_data (long i, int thr, int iter)$/;" f file: +set_data testsuite/libgomp.c/ordered-1.c /^static void set_data (long i, int val)$/;" f file: +set_data testsuite/libgomp.c/ordered-2.c /^static void set_data (long i)$/;" f file: +set_data testsuite/libgomp.c/sections-1.c /^static void set_data (unsigned i, int val)$/;" f file: +set_stream_func libgomp.h /^ __typeof (GOMP_OFFLOAD_openacc_cuda_set_stream) *set_stream_func;$/;" m struct:acc_dispatch_t::__anon52 +shift hashtab.h /^ hashval_t shift;$/;" m struct:prime_ent +shift_counts libgomp.h /^ unsigned int shift_counts[];$/;" m struct:gomp_doacross_work_share +signal plugin/plugin-hsa.c /^ uint64_t signal;$/;" m struct:GOMP_hsa_kernel_dispatch file: +simd_8f testsuite/libgomp.fortran/examples-4/simd-8.f90 /^program simd_8f$/;" p +simple_sgemm_tt testsuite/libgomp.hsa.c/tiling-1.c /^void simple_sgemm_tt(const int M,const int N,const int K,const float alpha, const float* A,const int LDA,$/;" f +simple_sgemm_tt testsuite/libgomp.hsa.c/tiling-2.c /^void simple_sgemm_tt(const int M,const int N,const int K,const float alpha, const float* A,const int LDA,$/;" f +single testsuite/libgomp.c++/single-3.C /^single (int a, int b)$/;" f +single testsuite/libgomp.c/omp-single-3.c /^single (int a, int b)$/;" f +single_count libgomp.h /^ unsigned long single_count;$/;" m struct:gomp_team +single_count libgomp.h /^ unsigned long single_count;$/;" m struct:gomp_team_state +singlethread testsuite/libgomp.c++/ctor-9.C /^static int singlethread;$/;" v file: +size hashtab.h /^ size_t size;$/;" m struct:htab +size plugin/hsa_ext_finalize.h /^ size_t size;$/;" m struct:hsa_ext_image_data_info_s +size plugin/plugin-nvptx.c /^ int size;$/;" m struct:ptx_device::__anon9 file: +size plugin/plugin-nvptx.c /^ size_t size;$/;" m struct:map file: +size plugin/plugin-nvptx.c /^ size_t size;$/;" m struct:targ_ptx_obj file: +size tdg.h /^ unsigned int size;$/;" m struct:tdg_func_hash_table +size testsuite/libgomp.hsa.c/alloca-1.c 1;" d file: +size testsuite/libgomp.hsa.c/function-call-1.c 1;" d file: +size testsuite/libgomp.oacc-fortran/non-scalar-data.f90 /^ integer,parameter :: size /;" v program:main +size_int_pair_stack testsuite/libgomp.c/sort-1.c /^size_int_pair_stack (struct int_pair_stack *stack)$/;" f file: +size_prime_index hashtab.h /^ unsigned int size_prime_index;$/;" m struct:htab +sizes libgomp.h /^ size_t *sizes;$/;" m struct:gomp_target_task +skip testsuite/libgomp.c/appendix-a/a.39.1.c /^skip (int i)$/;" f +software openacc_lib.h /^! Libgomp is free software; you can redistribute it and\/or modify it$/;" v +something testsuite/libgomp.fortran/pr33880.f90 /^ subroutine something(/;" s program:pr33880 +sort1 testsuite/libgomp.c/sort-1.c /^sort1 (int *array, int count)$/;" f file: +sort2 testsuite/libgomp.c/sort-1.c /^sort2 (int *array, int count)$/;" f file: +sort2_1 testsuite/libgomp.c/sort-1.c /^sort2_1 (int *array, int lo, int hi, int num_threads, int *busy)$/;" f file: +sort3 testsuite/libgomp.c/sort-1.c /^sort3 (int *array, int count)$/;" f file: +sort3_1 testsuite/libgomp.c/sort-1.c /^sort3_1 (int *array, int lo, int hi)$/;" f file: +splay_compare libgomp.h /^splay_compare (splay_tree_key x, splay_tree_key y)$/;" f +splay_compare splay-tree.h 118;" d +splay_compare splay-tree.h 71;" d +splay_tree libgomp.h /^typedef struct splay_tree_s *splay_tree;$/;" t typeref:struct:splay_tree_s +splay_tree splay-tree.h 116;" d +splay_tree splay-tree.h 67;" d +splay_tree_c priority_queue.c 332;" d file: +splay_tree_c splay-tree.h 124;" d +splay_tree_callback splay-tree.h /^typedef void (*splay_tree_callback) (splay_tree_key, void *);$/;" t +splay_tree_callback splay-tree.h 123;" d +splay_tree_callback splay-tree.h 81;" d +splay_tree_foreach splay-tree.c /^splay_tree_foreach (splay_tree sp, splay_tree_callback func, void *data)$/;" f +splay_tree_foreach splay-tree.h 122;" d +splay_tree_foreach splay-tree.h 79;" d +splay_tree_foreach_internal splay-tree.c /^splay_tree_foreach_internal (splay_tree_node node, splay_tree_callback func,$/;" f file: +splay_tree_insert splay-tree.c /^splay_tree_insert (splay_tree sp, splay_tree_node node)$/;" f +splay_tree_insert splay-tree.h 120;" d +splay_tree_insert splay-tree.h 75;" d +splay_tree_key libgomp.h /^typedef struct splay_tree_key_s *splay_tree_key;$/;" t typeref:struct:splay_tree_key_s +splay_tree_key splay-tree.h 117;" d +splay_tree_key splay-tree.h 69;" d +splay_tree_key_s libgomp.h /^struct splay_tree_key_s {$/;" s +splay_tree_key_s splay-tree.h 114;" d +splay_tree_key_s splay-tree.h 63;" d +splay_tree_lookup splay-tree.c /^splay_tree_lookup (splay_tree sp, splay_tree_key key)$/;" f +splay_tree_lookup splay-tree.h 119;" d +splay_tree_lookup splay-tree.h 73;" d +splay_tree_name splay-tree.h 111;" d +splay_tree_name splay-tree.h 58;" d +splay_tree_name_1 splay-tree.h 110;" d +splay_tree_name_1 splay-tree.h 57;" d +splay_tree_node libgomp.h /^typedef struct splay_tree_node_s *splay_tree_node;$/;" t typeref:struct:splay_tree_node_s +splay_tree_node splay-tree.h 115;" d +splay_tree_node splay-tree.h 65;" d +splay_tree_node_s splay-tree.h /^struct splay_tree_node_s {$/;" s +splay_tree_node_s splay-tree.h 112;" d +splay_tree_node_s splay-tree.h 59;" d +splay_tree_prefix priority_queue.c 331;" d file: +splay_tree_prefix priority_queue.h 75;" d +splay_tree_prefix splay-tree.h 129;" d +splay_tree_remove splay-tree.c /^splay_tree_remove (splay_tree sp, splay_tree_key key)$/;" f +splay_tree_remove splay-tree.h 121;" d +splay_tree_remove splay-tree.h 77;" d +splay_tree_s splay-tree.h /^struct splay_tree_s {$/;" s +splay_tree_s splay-tree.h 113;" d +splay_tree_s splay-tree.h 61;" d +splay_tree_splay splay-tree.c /^splay_tree_splay (splay_tree sp, splay_tree_key key)$/;" f file: +stack testsuite/libgomp.fortran/stack.f90 /^program stack$/;" p +stamps testsuite/libgomp.c/barrier-1.c /^struct timeval stamps[3][3];$/;" v typeref:struct:timeval +star testsuite/libgomp.c/examples-4/simd-1.c /^void star( double *a, double *b, double *c, int n, int *ioff )$/;" f +star testsuite/libgomp.fortran/examples-4/simd-1.f90 /^ subroutine star(/;" s module:SIMD1_mod +star_ref testsuite/libgomp.c/examples-4/simd-1.c /^void star_ref( double *a, double *b, double *c, int n, int *ioff )$/;" f +start libgomp-plugin.h /^ uintptr_t start;$/;" m struct:addr_pair +start testsuite/libgomp.c/affinity-1.c /^ int start, len;$/;" m struct:place file: +start testsuite/libgomp.fortran/strassen.f90 /^ double precision :: start,/;" v program:strassen_matmul +start_timer testsuite/libgomp.oacc-c-c++-common/timer.h /^start_timer (int timer)$/;" f +state libgomp.h /^ enum gomp_device_state state;$/;" m struct:gomp_device_descr typeref:enum:gomp_device_descr::gomp_device_state +state libgomp.h /^ enum gomp_target_task_state state;$/;" m struct:gomp_target_task typeref:enum:gomp_target_task::gomp_target_task_state +static_trip libgomp.h /^ unsigned long static_trip;$/;" m struct:gomp_team_state +stop_timer testsuite/libgomp.oacc-c-c++-common/timer.h /^stop_timer (int timer)$/;" f +strassen testsuite/libgomp.fortran/strassen.f90 /^ recursive subroutine strassen /;" s +strassen_matmul testsuite/libgomp.fortran/strassen.f90 /^program strassen_matmul$/;" p +stream plugin/plugin-nvptx.c /^ CUstream stream;$/;" m struct:ptx_stream file: +stream_lock plugin/plugin-nvptx.c /^ pthread_mutex_t stream_lock;$/;" m struct:ptx_device file: +stride testsuite/libgomp.hsa.c/tiling-1.c /^ int stride;$/;" m struct:__anon23 file: +stride testsuite/libgomp.hsa.c/tiling-2.c /^ int stride;$/;" m struct:__anon22 file: +strong_alias libgomp.h 1103;" d +strtoull env.c 57;" d file: +sub testsuite/libgomp.c/appendix-a/a.4.1.c /^sub (float *x, int npoints)$/;" f +sub testsuite/libgomp.fortran/allocatable6.f90 /^subr/;" s +sub testsuite/libgomp.fortran/recursion1.f90 /^ subr/;" s +sub1 testsuite/libgomp.c/appendix-a/a.15.1.c /^sub1 (int n)$/;" f +sub1 testsuite/libgomp.fortran/pr42162.f90 /^subroutine sub1(/;" s +sub1 testsuite/libgomp.fortran/retval2.f90 /^ subroutine sub1$/;" s function:f1 +sub1 testsuite/libgomp.fortran/udr12.f90 /^elemental subroutine sub1 /;" s +sub1 testsuite/libgomp.fortran/udr13.f90 /^subroutine sub1 /;" s +sub2 testsuite/libgomp.c/appendix-a/a.15.1.c /^sub2 (int k)$/;" f +sub2 testsuite/libgomp.fortran/pr42162.f90 /^subroutine sub2(/;" s +sub2 testsuite/libgomp.fortran/udr12.f90 /^elemental subroutine sub2 /;" s +sub2 testsuite/libgomp.fortran/udr13.f90 /^subroutine sub2 /;" s +sub3 testsuite/libgomp.c/appendix-a/a.15.1.c /^sub3 (int n)$/;" f +sub3 testsuite/libgomp.fortran/pr42162.f90 /^subroutine sub3(/;" s +sub3 testsuite/libgomp.fortran/udr13.f90 /^subroutine sub3 /;" s +sub_collapse_3 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^program sub_collapse_3$/;" p +subarrays testsuite/libgomp.oacc-fortran/subarrays-1.f90 /^program subarrays$/;" p +subarrays testsuite/libgomp.oacc-fortran/subarrays-2.f90 /^program subarrays$/;" p +subdomain testsuite/libgomp.c/appendix-a/a.4.1.c /^subdomain (float *x, int istart, int ipoints)$/;" f +subr testsuite/libgomp.fortran/task1.f90 /^ subro/;" s program:tasktest +subr0 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr0 /;" s +subr1 testsuite/libgomp.oacc-c-c++-common/declare-1.c /^subr1 (int *a)$/;" f +subr1 testsuite/libgomp.oacc-c-c++-common/declare-2.c /^subr1 (float a)$/;" f +subr1 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr1 /;" s +subr2 testsuite/libgomp.oacc-c-c++-common/declare-1.c /^subr2 (int *a)$/;" f +subr2 testsuite/libgomp.oacc-c-c++-common/declare-2.c /^subr2 (float a)$/;" f +subr2 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr2 /;" s +subr3 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr3 /;" s +subr4 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr4 /;" s +subr5 testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine subr5 /;" s +subzero testsuite/libgomp.oacc-c-c++-common/zero_length_subarrays.c /^subzero (int *a, int n)$/;" f +subzero_present testsuite/libgomp.oacc-c-c++-common/zero_length_subarrays.c /^subzero_present (int *a, int n)$/;" f +suitable_hsa_agent_p plugin/plugin-hsa.c /^suitable_hsa_agent_p (hsa_agent_t agent)$/;" f file: +sum testsuite/libgomp.c/omp_orphan.c /^float a[VECLEN], b[VECLEN], sum;$/;" v +sum testsuite/libgomp.c/target-20.c /^int sum;$/;" v +sum testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ double precision :: a(128), b(128), sum,/;" v program:SIMD3 +sum testsuite/libgomp.fortran/task3.f90 /^ integer :: sum /;" v program:F03_2_7_1d +sum testsuite/libgomp.oacc-c++/template-reduction.C /^sum ()$/;" f +sum testsuite/libgomp.oacc-c++/template-reduction.C /^sum (T array[])$/;" f +sum testsuite/libgomp.oacc-fortran/pr68813.f90 /^ integer :: i, j, sum /;" v program:foo +sum testsuite/libgomp.oacc-fortran/pr70643.f90 /^ real(kind=8) :: sum$/;" v program:main +sum_ref testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ double precision :: a(128), b(128), sum, sum_ref,/;" v program:SIMD3 +sumarray testsuite/libgomp.fortran/pr27395-1.f90 /^ integer, dimension(n) :: sumarray$/;" v program:pr27395_1 +support_cpu_devices plugin/plugin-hsa.c /^static bool support_cpu_devices;$/;" v file: +suppress_host_fallback plugin/plugin-hsa.c /^static bool suppress_host_fallback;$/;" v file: +swap testsuite/libgomp.c/sort-1.c /^swap (int *array, int a, int b)$/;" f file: +switch1 testsuite/libgomp.hsa.c/switch-1.c /^switch1 (int a)$/;" f +switch1 testsuite/libgomp.hsa.c/switch-branch-1.c /^switch1 (unsigned a)$/;" f +switch2 testsuite/libgomp.hsa.c/switch-1.c /^switch2 (int a)$/;" f +switch2 testsuite/libgomp.hsa.c/switch-branch-1.c /^switch2 (unsigned a)$/;" f +switch3 testsuite/libgomp.hsa.c/switch-1.c /^switch3 (int a)$/;" f +switch3 testsuite/libgomp.hsa.c/switch-branch-1.c /^switch3 (unsigned a)$/;" f +switch4 testsuite/libgomp.hsa.c/switch-1.c /^switch4 (int a, int b)$/;" f +switch4 testsuite/libgomp.hsa.c/switch-branch-1.c /^switch4 (unsigned a)$/;" f +switch5 testsuite/libgomp.hsa.c/switch-1.c /^switch5 (int a, int b)$/;" f +synch testsuite/libgomp.c/appendix-a/a.18.1.c /^int synch[NUMBER_OF_THREADS];$/;" v +sys_futex0 config/linux/ia64/futex.h /^sys_futex0(int *addr, int op, int val)$/;" f +sys_futex0 config/linux/mips/futex.h /^sys_futex0 (int *addr, int op, int val)$/;" f +sys_futex0 config/linux/powerpc/futex.h /^sys_futex0 (int *addr, int op, int val)$/;" f +sys_futex0 config/linux/s390/futex.h /^sys_futex0 (int *addr, int op, int val)$/;" f +sys_futex0 config/linux/sparc/futex.h /^sys_futex0 (int *addr, int op, int val)$/;" f +sys_futex0 config/linux/tile/futex.h /^sys_futex0 (int *addr, int op, int val)$/;" f +t libgomp.h /^ long t;$/;" m struct:gomp_doacross_work_share +t priority_queue.h /^ struct prio_splay_tree_s t;$/;" m struct:priority_queue typeref:struct:priority_queue::prio_splay_tree_s +t testsuite/libgomp.c++/copyin-2.C /^struct S { int t; char buf[64]; } thr = { 32, "" };$/;" m struct:S file: +t testsuite/libgomp.c++/member-1.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-2.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-3.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-4.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-5.C /^struct T { T () {}; virtual ~T () {}; I t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-5.C /^struct U { U () {}; virtual ~U () {}; Q t; };$/;" m struct:U file: +t testsuite/libgomp.c++/member-6.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" m struct:T file: +t testsuite/libgomp.c++/member-7.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" m struct:T file: +t testsuite/libgomp.c++/pr66702-2.C /^struct T { T (); ~T (); int t; };$/;" m struct:T file: +t testsuite/libgomp.c++/reduction-10.C /^ T t;$/;" m struct:A file: +t testsuite/libgomp.c++/reduction-10.C /^ T t;$/;" m struct:B file: +t testsuite/libgomp.c++/reduction-10.C /^ T t;$/;" m struct:M file: +t testsuite/libgomp.c++/reduction-12.C /^ T t;$/;" m struct:A file: +t testsuite/libgomp.c++/reduction-12.C /^ T t;$/;" m struct:B file: +t testsuite/libgomp.c++/reduction-12.C /^ T t;$/;" m struct:M file: +t testsuite/libgomp.c++/reduction-6.C /^ T t;$/;" m struct:A file: +t testsuite/libgomp.c++/reduction-6.C /^ T t;$/;" m struct:B file: +t testsuite/libgomp.c++/reduction-6.C /^ T t;$/;" m struct:M file: +t testsuite/libgomp.c++/reduction-8.C /^ T t;$/;" m struct:A file: +t testsuite/libgomp.c++/reduction-8.C /^ T t;$/;" m struct:B file: +t testsuite/libgomp.c++/reduction-8.C /^ T t;$/;" m struct:M file: +t testsuite/libgomp.c++/target-21.C /^struct S { int (&x)[10]; int *&y; T t; int &z; S (); ~S (); };$/;" m struct:S file: +t testsuite/libgomp.c++/target-21.C /^struct T { char t[270]; };$/;" m struct:T file: +t testsuite/libgomp.c++/target-6.C /^struct S { int s, t; };$/;" m struct:S file: +t testsuite/libgomp.c/copyin-2.c /^struct { int t; char buf[64]; } thr = { 32, "" };$/;" m struct:__anon27 file: +t testsuite/libgomp.c/reduction-10.c /^struct A { int t; };$/;" m struct:A file: +t testsuite/libgomp.c/reduction-10.c /^struct B { char t; };$/;" m struct:B file: +t testsuite/libgomp.c/reduction-10.c /^struct C { unsigned long long t; };$/;" m struct:C file: +t testsuite/libgomp.c/reduction-10.c /^struct D { long t; };$/;" m struct:D file: +t testsuite/libgomp.c/reduction-12.c /^struct A { int t; };$/;" m struct:A file: +t testsuite/libgomp.c/reduction-12.c /^struct B { char t; };$/;" m struct:B file: +t testsuite/libgomp.c/reduction-12.c /^struct C { unsigned long long t; };$/;" m struct:C file: +t testsuite/libgomp.c/reduction-12.c /^struct D { long t; };$/;" m struct:D file: +t testsuite/libgomp.c/reduction-14.c /^struct A { int t; };$/;" m struct:A file: +t testsuite/libgomp.c/reduction-14.c /^struct B { char t; };$/;" m struct:B file: +t testsuite/libgomp.c/reduction-14.c /^struct C { unsigned long long t; };$/;" m struct:C file: +t testsuite/libgomp.c/reduction-14.c /^struct D { long t; };$/;" m struct:D file: +t testsuite/libgomp.c/reduction-8.c /^struct A { int t; };$/;" m struct:A file: +t testsuite/libgomp.c/reduction-8.c /^struct B { char t; };$/;" m struct:B file: +t testsuite/libgomp.c/reduction-8.c /^struct C { unsigned long long t; };$/;" m struct:C file: +t testsuite/libgomp.c/reduction-8.c /^struct D { long t; };$/;" m struct:D file: +t testsuite/libgomp.c/target-13.c /^struct S { int s, t; };$/;" m struct:S file: +t testsuite/libgomp.c/target-link-1.c /^struct S { int s, t; };$/;" m struct:S file: +t testsuite/libgomp.c/udr-1.c /^struct S { int s; struct S *t; };$/;" m struct:S typeref:struct:S::S file: +t testsuite/libgomp.fortran/associate3.f90 /^ ty/;" t +t testsuite/libgomp.fortran/pointer2.f90 /^ inte/;" v +t testsuite/libgomp.fortran/pr63938-2.f90 /^ ty/;" t program:pr63938_2 +t testsuite/libgomp.fortran/pr71014.f90 /^ inte/;" v program:pr71014 +t testsuite/libgomp.fortran/simd1.f90 /^ ty/;" v +t testsuite/libgomp.fortran/simd2.f90 /^ inte/;" v +t testsuite/libgomp.fortran/simd3.f90 /^ inte/;" v +t testsuite/libgomp.fortran/simd4.f90 /^ inte/;" v +t testsuite/libgomp.fortran/udr11.f90 /^ ty/;" v +t testsuite/libgomp.oacc-fortran/implicit-firstprivate-ref.f90 /^program t$/;" p +t1 testsuite/libgomp.fortran/pr66680.f90 /^ type :: t1$/;" t module:m1 +t1 testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c /^void t1 ()$/;" f +t1 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t1()$/;" f +t1 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t1(/;" s +t10 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t10()$/;" f +t10 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t10(/;" s +t11 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t11()$/;" f +t11 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t11(/;" s +t12 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t12()$/;" f +t12 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t12(/;" s +t13 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t13()$/;" f +t13 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t13(/;" s +t14 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t14(/;" s +t16 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t16()$/;" f +t17 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t17()$/;" f +t18 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t18()$/;" f +t19 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t19()$/;" f +t2 testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c /^void t2 ()$/;" f +t2 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t2()$/;" f +t2 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t2(/;" s +t20 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t20()$/;" f +t21 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t21()$/;" f +t22 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t22()$/;" f +t23 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t23()$/;" f +t24 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t24()$/;" f +t25 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t25()$/;" f +t27 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t27()$/;" f +t28 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t28()$/;" f +t28_routine testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^float t28_routine ()$/;" f +t3 testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c /^void t3 ()$/;" f +t3 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t3(/;" s +t4 testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c /^void t4 ()$/;" f +t4 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t4()$/;" f +t4 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t4(/;" s +t5 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t5()$/;" f +t5 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t5(/;" s +t6 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t6(/;" s +t7 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t7()$/;" f +t7 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t7(/;" s +t8 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t8()$/;" f +t8 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t8(/;" s +t9 testsuite/libgomp.oacc-c-c++-common/mode-transitions.c /^void t9()$/;" f +t9 testsuite/libgomp.oacc-fortran/private-variables.f90 /^subroutine t9(/;" s +ta testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j, ja (6), k, ka (6), ta /;" v +take testsuite/libgomp.c++/member-1.C /^take (int &a, int &b, int &c, int &d)$/;" f +take testsuite/libgomp.c++/member-2.C /^take (int &a, int &b, int &c, int &d)$/;" f +take testsuite/libgomp.c++/member-6.C /^take (int &a, int &b, int &c, int &d)$/;" f +take testsuite/libgomp.c++/member-7.C /^take (int &a, int &b, int &c, int &d)$/;" f +targ testsuite/libgomp.fortran/pr32550.f90 /^ integer, targe/;" v +targ_fn_descriptor plugin/plugin-nvptx.c /^struct targ_fn_descriptor$/;" s file: +targ_fn_launch plugin/plugin-nvptx.c /^struct targ_fn_launch$/;" s file: +targ_ptx_obj plugin/plugin-nvptx.c /^struct targ_ptx_obj$/;" s file: +target1 testsuite/libgomp.fortran/target1.f90 /^module target1$/;" m +target2 testsuite/libgomp.fortran/target2.f90 /^module target2$/;" m +target3 testsuite/libgomp.fortran/target3.f90 /^module target3$/;" m +target4 testsuite/libgomp.fortran/target4.f90 /^module target4$/;" m +target6 testsuite/libgomp.fortran/target6.f90 /^module target6$/;" m +target_data libgomp.h /^ struct target_mem_desc *target_data;$/;" m struct:gomp_task_icv typeref:struct:gomp_task_icv::target_mem_desc +target_data plugin/plugin-nvptx.c /^ const void *target_data;$/;" m struct:ptx_image_data file: +target_data target.c /^ const void *target_data;$/;" m struct:offload_image_descr file: +target_id libgomp.h /^ int target_id;$/;" m struct:gomp_device_descr +target_mem_desc libgomp.h /^struct target_mem_desc {$/;" s +target_tls oacc-int.h /^ void *target_tls;$/;" m struct:goacc_thread +target_var_desc libgomp.h /^struct target_var_desc {$/;" s +task libgomp.h /^ struct gomp_task *task;$/;" m struct:gomp_target_task typeref:struct:gomp_target_task::gomp_task +task libgomp.h /^ struct gomp_task *task;$/;" m struct:gomp_task_depend_entry typeref:struct:gomp_task_depend_entry::gomp_task +task libgomp.h /^ struct gomp_task *task;$/;" m struct:gomp_thread typeref:struct:gomp_thread::gomp_task +task libgomp.h /^ struct gomp_task task;$/;" m union:task_union_t typeref:struct:task_union_t::gomp_task +task tdg.h /^ struct gomp_tdg_task *task; \/\/ pointer to actual task$/;" m struct:gomp_tdg_node typeref:struct:gomp_tdg_node::gomp_tdg_task +task team.c /^ struct gomp_task *task;$/;" m struct:gomp_thread_start_data typeref:struct:gomp_thread_start_data::gomp_task file: +task_count libgomp.h /^ unsigned int task_count;$/;" m struct:gomp_team +task_counter tdg.h /^ long task_counter; \/\/ Private counter assigned to each task instance to compute execution time while executing in parallel$/;" m struct:gomp_tdg_node +task_counter_end tdg.h /^ long task_counter_end; \/\/ Private counter assigned to each task instance that contains the final time of a task$/;" m struct:gomp_tdg_node +task_dep5_mod testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^module task_dep5_mod$/;" m +task_lock libgomp.h /^ gomp_mutex_t task_lock;$/;" m struct:gomp_team +task_queue libgomp.h /^ struct priority_queue task_queue;$/;" m struct:gomp_team typeref:struct:gomp_team::priority_queue +task_queued_count libgomp.h /^ unsigned int task_queued_count;$/;" m struct:gomp_team +task_running_count libgomp.h /^ unsigned int task_running_count;$/;" m struct:gomp_team +task_to_priority_node libgomp.h /^task_to_priority_node (enum priority_queue_type type,$/;" f +task_u tdg.h /^ union task_union_t *task_u;$/;" m struct:root_list typeref:union:root_list::task_union_t +task_union_t libgomp.h /^union task_union_t$/;" u +taskgroup libgomp.h /^ struct gomp_taskgroup *taskgroup;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_taskgroup +taskgroup_queue libgomp.h /^ struct priority_queue taskgroup_queue;$/;" m struct:gomp_taskgroup typeref:struct:gomp_taskgroup::priority_queue +taskgroup_sem libgomp.h /^ gomp_sem_t taskgroup_sem;$/;" m struct:gomp_taskgroup +taskpart_counter tdg.h /^ long taskpart_counter; \/\/ Private counter assigned to each task part executed just before the corresponding task$/;" m struct:gomp_tdg_node +tasks priority_queue.h /^ struct priority_node *tasks;$/;" m struct:priority_list typeref:struct:priority_list::priority_node +tasktest testsuite/libgomp.fortran/task1.f90 /^program tasktest$/;" p +tasktest_j testsuite/libgomp.fortran/task1.f90 21;" c subroutine:subr +tasktest_j testsuite/libgomp.fortran/task1.f90 6;" c program:tasktest +taskwait libgomp.h /^ struct gomp_taskwait *taskwait;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_taskwait +taskwait_sem libgomp.h /^ gomp_sem_t taskwait_sem;$/;" m struct:gomp_taskwait +tdg libgomp.h /^ struct gomp_tdg_node *tdg;$/;" m struct:gomp_task typeref:struct:gomp_task::gomp_tdg_node +tdg libgomp.h /^ struct gomp_tdg_node *tdg;$/;" m struct:gomp_tdg_task typeref:struct:gomp_tdg_task::gomp_tdg_node +tdg_entry_create tdg.h /^static tdg_hash_entry *tdg_entry_create (void *fn)$/;" f +tdg_func_hash_entry tdg.h /^typedef struct tdg_func_hash_entry$/;" s +tdg_func_hash_table tdg.h /^typedef struct tdg_func_hash_table$/;" s +tdg_g tdg.c /^struct gomp_tdg_node **tdg_g; \/\/ tdg matrix of the program => 1 row = 1 tdg$/;" v typeref:struct:gomp_tdg_node +tdg_hash tdg.h /^static unsigned int tdg_hash (void *fn)$/;" f +tdg_hash_entry tdg.h /^}tdg_hash_entry;$/;" t typeref:struct:tdg_func_hash_entry +tdg_hash_find tdg.h /^static bool tdg_hash_find (tdg_hash_table *htab, void *fn)$/;" f +tdg_hash_table tdg.h /^}tdg_hash_table;$/;" t typeref:struct:tdg_func_hash_table +tdg_htab_g tdg.c /^tdg_hash_table *tdg_htab_g = NULL; \/\/ hash table handling tdg record functions$/;" v +tdg_index_lookup tdg.h /^tdg_index_lookup(unsigned id)$/;" f +tdg_ins_g tdg.c /^unsigned short **tdg_ins_g; \/\/ input dependency matrix of the tdg matrix$/;" v +tdg_ntasks_g tdg.c /^unsigned int *tdg_ntasks_g; \/\/ number of tasks in different tdg$/;" v +tdg_outs_g tdg.c /^unsigned short **tdg_outs_g; \/\/ output dependecy matrix of the tdg matrix$/;" v +tdg_task libgomp.h /^ struct gomp_tdg_task tdg_task;$/;" m union:task_union_t typeref:struct:task_union_t::gomp_tdg_task +tdg_task_to_priority_node libgomp.h /^tdg_task_to_priority_node (enum priority_queue_type type,$/;" f +team libgomp.h /^ struct gomp_team *team;$/;" m struct:gomp_target_task typeref:struct:gomp_target_task::gomp_team +team libgomp.h /^ struct gomp_team *team;$/;" m struct:gomp_team_state typeref:struct:gomp_team_state::gomp_team +team_cancelled libgomp.h /^ int team_cancelled;$/;" m struct:gomp_team +team_destructor team.c /^team_destructor (void)$/;" f file: +team_id libgomp.h /^ unsigned team_id;$/;" m struct:gomp_team_state +temp testsuite/libgomp.oacc-fortran/pr70289.f90 /^ integer :: temp /;" v program:foo +temp2 testsuite/libgomp.oacc-fortran/pr70289.f90 /^ integer :: temp2 /;" v program:foo +test testsuite/libgomp.c++/loop-12.C 22;" d file: +test testsuite/libgomp.c++/loop-6.C /^static int test(void)$/;" f file: +test testsuite/libgomp.c++/loop-9.C 22;" d file: +test testsuite/libgomp.c++/pr26943.C /^S::test ()$/;" f class:S +test testsuite/libgomp.c/atomic-2.c /^test (void)$/;" f +test testsuite/libgomp.c/copyin-3.c /^test (int l)$/;" f +test testsuite/libgomp.c/critical-1.c /^static volatile int test = -1;$/;" v file: +test testsuite/libgomp.c/for-2.h /^N(test) (void)$/;" f +test testsuite/libgomp.c/loop-1.c /^static void test (void)$/;" f file: +test testsuite/libgomp.c/loop-12.c 22;" d file: +test testsuite/libgomp.c/loop-16.c /^static int test (void)$/;" f file: +test testsuite/libgomp.c/loop-2.c /^static void test (void)$/;" f file: +test testsuite/libgomp.c/loop-3.c /^static int test(void)$/;" f file: +test testsuite/libgomp.c/loop-6.c 22;" d file: +test testsuite/libgomp.c/ordered-1.c /^static void test (void)$/;" f file: +test testsuite/libgomp.c/ordered-2.c /^static void test (void)$/;" f file: +test testsuite/libgomp.c/pr29947-1.c /^test (long j1, long k1, long j2, long k2)$/;" f +test testsuite/libgomp.c/pr29947-2.c /^test (long j1, long k1, long j2, long k2)$/;" f +test testsuite/libgomp.c/single-1.c /^static int test;$/;" v file: +test testsuite/libgomp.c/taskloop-4.c /^test (int a, int b, int c, int d, void (*fn) (int, int, int, int),$/;" f +test testsuite/libgomp.c/udr-1.c /^test (struct S s, struct S t)$/;" f +test testsuite/libgomp.fortran/character1.f90 /^ subroutine test /;" s +test testsuite/libgomp.fortran/character2.f90 /^ subroutine test /;" s +test testsuite/libgomp.fortran/examples-4/simd-6.f90 /^ subroutine test /;" s module:SIMD6_mod +test testsuite/libgomp.fortran/pr32359.f90 /^subroutine test$/;" s +test testsuite/libgomp.fortran/pr66680.f90 /^ type(t1), allocatable :: test(/;" v module:m2 +test testsuite/libgomp.fortran/reference1.f90 /^ subroutine test /;" s +test testsuite/libgomp.fortran/task2.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/taskloop4.f90 /^ subroutine test /;" s +test testsuite/libgomp.fortran/vla1.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla2.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla3.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla4.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla5.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla6.f90 /^ subroutine test$/;" s +test testsuite/libgomp.fortran/vla8.f90 /^ subroutine test$/;" s +test testsuite/libgomp.oacc-c-c++-common/gang-static-1.c /^test (int *a, int *b, int sarg)$/;" f +test testsuite/libgomp.oacc-c-c++-common/lib-88.c /^test (void *arg)$/;" f file: +test testsuite/libgomp.oacc-c-c++-common/lib-89.c /^test (void *arg)$/;" f file: +test testsuite/libgomp.oacc-c-c++-common/lib-90.c /^test (void *arg)$/;" f file: +test testsuite/libgomp.oacc-c-c++-common/lib-92.c /^test (void *arg)$/;" f file: +test testsuite/libgomp.oacc-c-c++-common/vprop.c 6;" d file: +test testsuite/libgomp.oacc-fortran/combined-reduction.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/data-1.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/data-2.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/declare-1.f90 /^subroutine test /;" s +test testsuite/libgomp.oacc-fortran/declare-2.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/declare-3.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/declare-4.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/declare-5.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^subroutine test /;" s +test testsuite/libgomp.oacc-fortran/host_data-1.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/implicit-firstprivate-ref.f90 /^ subroutine test(/;" s module:test_mod +test testsuite/libgomp.oacc-fortran/pointer-align-1.f90 /^program test$/;" p +test testsuite/libgomp.oacc-fortran/pset-1.f90 /^program test$/;" p +test1 testsuite/libgomp.c++/ctor-11.C /^test1 ()$/;" f +test1 testsuite/libgomp.c++/loop-10.C /^test1 (void)$/;" f +test1 testsuite/libgomp.c++/loop-11.C /^test1 ()$/;" f +test1 testsuite/libgomp.c++/loop-12.C /^test1 ()$/;" f +test1 testsuite/libgomp.c++/loop-8.C /^test1 ()$/;" f +test1 testsuite/libgomp.c++/loop-9.C /^test1 ()$/;" f +test1 testsuite/libgomp.c/loop-11.c /^test1 (void)$/;" f +test1 testsuite/libgomp.c/loop-12.c /^test1 (void)$/;" f +test1 testsuite/libgomp.c/loop-5.c /^test1 (void)$/;" f +test1 testsuite/libgomp.c/loop-6.c /^test1 (void)$/;" f +test1 testsuite/libgomp.c/loop-7.c /^test1 (void)$/;" f +test1 testsuite/libgomp.c/pr29947-1.c /^test1 (long j1, long k1, long j2, long k2)$/;" f +test1 testsuite/libgomp.c/pr29947-2.c /^test1 (long j1, long k1, long j2, long k2)$/;" f +test1 testsuite/libgomp.c/pr33880.c /^test1 (void)$/;" f +test1 testsuite/libgomp.fortran/collapse2.f90 /^ subroutine test1$/;" s program:collapse2 +test1 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test1$/;" s program:collapse3 +test1 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test1$/;" s program:lastprivate +test1 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test1$/;" s program:lastprivate +test1 testsuite/libgomp.fortran/nestedfn2.f90 /^subroutine test1$/;" s +test1 testsuite/libgomp.fortran/nestedfn4.f90 /^ subroutine test1$/;" s program:foo +test1 testsuite/libgomp.fortran/reduction5.f90 /^ subroutine test1$/;" s +test1 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^ subroutine test1$/;" s program:collapse2 +test1 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ subroutine test1$/;" s program:collapse3 +test1 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test1$/;" s program:sub_collapse_3 +test10 testsuite/libgomp.c/pr29947-1.c /^test10 (long j1, long k1, long j2, long k2)$/;" f +test10 testsuite/libgomp.c/pr29947-2.c /^test10 (long j1, long k1, long j2, long k2)$/;" f +test10 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test10$/;" s program:lastprivate +test10 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test10$/;" s program:lastprivate +test11 testsuite/libgomp.c/pr29947-1.c /^test11 (long j1, long k1, long j2, long k2)$/;" f +test11 testsuite/libgomp.c/pr29947-2.c /^test11 (long j1, long k1, long j2, long k2)$/;" f +test11 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test11$/;" s program:lastprivate +test11 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test11$/;" s program:lastprivate +test12 testsuite/libgomp.c/pr29947-1.c /^test12 (long j1, long k1, long j2, long k2)$/;" f +test12 testsuite/libgomp.c/pr29947-2.c /^test12 (long j1, long k1, long j2, long k2)$/;" f +test12 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test12$/;" s program:lastprivate +test12 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test12$/;" s program:lastprivate +test13 testsuite/libgomp.c/pr29947-1.c /^test13 (long j1, long k1, long j2, long k2)$/;" f +test13 testsuite/libgomp.c/pr29947-2.c /^test13 (long j1, long k1, long j2, long k2)$/;" f +test14 testsuite/libgomp.c/pr29947-1.c /^test14 (long j1, long k1, long j2, long k2)$/;" f +test14 testsuite/libgomp.c/pr29947-2.c /^test14 (long j1, long k1, long j2, long k2)$/;" f +test15 testsuite/libgomp.c/pr29947-1.c /^test15 (long j1, long k1, long j2, long k2)$/;" f +test15 testsuite/libgomp.c/pr29947-2.c /^test15 (long j1, long k1, long j2, long k2)$/;" f +test16 testsuite/libgomp.c/pr29947-1.c /^test16 (long j1, long k1, long j2, long k2)$/;" f +test16 testsuite/libgomp.c/pr29947-2.c /^test16 (long j1, long k1, long j2, long k2)$/;" f +test2 testsuite/libgomp.c++/ctor-11.C /^test2 ()$/;" f +test2 testsuite/libgomp.c++/loop-11.C /^test2 ()$/;" f +test2 testsuite/libgomp.c++/loop-12.C /^test2 ()$/;" f +test2 testsuite/libgomp.c++/loop-8.C /^test2 ()$/;" f +test2 testsuite/libgomp.c++/loop-9.C /^test2 ()$/;" f +test2 testsuite/libgomp.c/loop-11.c /^test2 (void)$/;" f +test2 testsuite/libgomp.c/loop-12.c /^test2 (void)$/;" f +test2 testsuite/libgomp.c/loop-5.c /^test2 (void)$/;" f +test2 testsuite/libgomp.c/loop-6.c /^test2 (void)$/;" f +test2 testsuite/libgomp.c/pr29947-1.c /^test2 (long j1, long k1, long j2, long k2)$/;" f +test2 testsuite/libgomp.c/pr29947-2.c /^test2 (long j1, long k1, long j2, long k2)$/;" f +test2 testsuite/libgomp.c/pr33880.c /^test2 (void)$/;" f +test2 testsuite/libgomp.fortran/collapse2.f90 /^ subroutine test2$/;" s program:collapse2 +test2 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test2(/;" s program:collapse3 +test2 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test2$/;" s program:lastprivate +test2 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test2$/;" s program:lastprivate +test2 testsuite/libgomp.fortran/nestedfn2.f90 /^ subroutine test2$/;" s subroutine:test1 +test2 testsuite/libgomp.fortran/nestedfn4.f90 /^ subroutine test2$/;" s program:foo +test2 testsuite/libgomp.fortran/reduction5.f90 /^ subroutine test2$/;" s +test2 testsuite/libgomp.oacc-fortran/nested-function-1.f90 /^ subroutine test2$/;" s program:collapse2 +test2 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ subroutine test2(/;" s program:collapse3 +test2 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test2(/;" s program:sub_collapse_3 +test3 testsuite/libgomp.c++/loop-11.C /^test3 ()$/;" f +test3 testsuite/libgomp.c++/loop-12.C /^test3 ()$/;" f +test3 testsuite/libgomp.c++/loop-8.C /^test3 ()$/;" f +test3 testsuite/libgomp.c++/loop-9.C /^test3 ()$/;" f +test3 testsuite/libgomp.c/loop-11.c /^test3 (void)$/;" f +test3 testsuite/libgomp.c/loop-12.c /^test3 (void)$/;" f +test3 testsuite/libgomp.c/loop-5.c /^test3 (void)$/;" f +test3 testsuite/libgomp.c/loop-6.c /^test3 (void)$/;" f +test3 testsuite/libgomp.c/pr29947-1.c /^test3 (long j1, long k1, long j2, long k2)$/;" f +test3 testsuite/libgomp.c/pr29947-2.c /^test3 (long j1, long k1, long j2, long k2)$/;" f +test3 testsuite/libgomp.c/pr33880.c /^test3 (void)$/;" f +test3 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test3(/;" s program:collapse3 +test3 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test3$/;" s program:lastprivate +test3 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test3$/;" s program:lastprivate +test3 testsuite/libgomp.fortran/nestedfn2.f90 /^ subroutine test3$/;" s subroutine:test1 +test3 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ subroutine test3(/;" s program:collapse3 +test3 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test3(/;" s program:sub_collapse_3 +test4 testsuite/libgomp.c++/loop-11.C /^test4 ()$/;" f +test4 testsuite/libgomp.c++/loop-12.C /^test4 ()$/;" f +test4 testsuite/libgomp.c++/loop-8.C /^test4 ()$/;" f +test4 testsuite/libgomp.c++/loop-9.C /^test4 ()$/;" f +test4 testsuite/libgomp.c/loop-11.c /^test4 (void)$/;" f +test4 testsuite/libgomp.c/loop-12.c /^test4 (void)$/;" f +test4 testsuite/libgomp.c/loop-5.c /^test4 (void)$/;" f +test4 testsuite/libgomp.c/loop-6.c /^test4 (void)$/;" f +test4 testsuite/libgomp.c/pr29947-1.c /^test4 (long j1, long k1, long j2, long k2)$/;" f +test4 testsuite/libgomp.c/pr29947-2.c /^test4 (long j1, long k1, long j2, long k2)$/;" f +test4 testsuite/libgomp.c/pr33880.c /^test4 (void)$/;" f +test4 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test4$/;" s program:collapse3 +test4 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test4$/;" s program:lastprivate +test4 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test4$/;" s program:lastprivate +test4 testsuite/libgomp.fortran/nestedfn2.f90 /^ subroutine test4$/;" s subroutine:test1 +test4 testsuite/libgomp.oacc-fortran/nested-function-2.f90 /^ subroutine test4$/;" s program:collapse3 +test4 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test4$/;" s program:sub_collapse_3 +test5 testsuite/libgomp.c++/loop-12.C /^test5 ()$/;" f +test5 testsuite/libgomp.c++/loop-9.C /^test5 ()$/;" f +test5 testsuite/libgomp.c/loop-12.c /^test5 (void)$/;" f +test5 testsuite/libgomp.c/loop-6.c /^test5 (void)$/;" f +test5 testsuite/libgomp.c/pr29947-1.c /^test5 (long j1, long k1, long j2, long k2)$/;" f +test5 testsuite/libgomp.c/pr29947-2.c /^test5 (long j1, long k1, long j2, long k2)$/;" f +test5 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test5(/;" s program:collapse3 +test5 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test5$/;" s program:lastprivate +test5 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test5$/;" s program:lastprivate +test5 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test5(/;" s program:sub_collapse_3 +test6 testsuite/libgomp.c/pr29947-1.c /^test6 (long j1, long k1, long j2, long k2)$/;" f +test6 testsuite/libgomp.c/pr29947-2.c /^test6 (long j1, long k1, long j2, long k2)$/;" f +test6 testsuite/libgomp.fortran/collapse3.f90 /^ subroutine test6(/;" s program:collapse3 +test6 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test6$/;" s program:lastprivate +test6 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test6$/;" s program:lastprivate +test6 testsuite/libgomp.oacc-fortran/nested-function-3.f90 /^ subroutine test6(/;" s program:sub_collapse_3 +test7 testsuite/libgomp.c/pr29947-1.c /^test7 (long j1, long k1, long j2, long k2)$/;" f +test7 testsuite/libgomp.c/pr29947-2.c /^test7 (long j1, long k1, long j2, long k2)$/;" f +test7 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test7$/;" s program:lastprivate +test7 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test7$/;" s program:lastprivate +test8 testsuite/libgomp.c/pr29947-1.c /^test8 (long j1, long k1, long j2, long k2)$/;" f +test8 testsuite/libgomp.c/pr29947-2.c /^test8 (long j1, long k1, long j2, long k2)$/;" f +test8 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test8$/;" s program:lastprivate +test8 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test8$/;" s program:lastprivate +test9 testsuite/libgomp.c/pr29947-1.c /^test9 (long j1, long k1, long j2, long k2)$/;" f +test9 testsuite/libgomp.c/pr29947-2.c /^test9 (long j1, long k1, long j2, long k2)$/;" f +test9 testsuite/libgomp.fortran/lastprivate1.f90 /^ subroutine test9$/;" s program:lastprivate +test9 testsuite/libgomp.fortran/lastprivate2.f90 /^ subroutine test9$/;" s program:lastprivate +test_1 testsuite/libgomp.c/sections-1.c /^static void test_1 (void)$/;" f file: +test_1 testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c /^int test_1 (int gp, int wp, int vp)$/;" f +test_2 testsuite/libgomp.c/sections-1.c /^static void test_2 (void)$/;" f file: +test_array_section testsuite/libgomp.c/target-11.c /^void test_array_section (int *p)$/;" f +test_atomic testsuite/libgomp.fortran/omp_parse2.f90 /^ subroutine test_atomic$/;" s +test_barrier testsuite/libgomp.fortran/omp_parse2.f90 /^ subroutine test_barrier$/;" s +test_bzero testsuite/libgomp.hsa.c/memory-operations-1.c /^test_bzero (unsigned size)$/;" f file: +test_critical testsuite/libgomp.fortran/omp_parse2.f90 /^ subroutine test_critical$/;" s +test_critical_1 testsuite/libgomp.fortran/omp_parse2.f90 /^ subroutine test_critical_1 /;" s +test_data testsuite/libgomp.c/loop-1.c /^static void test_data (void)$/;" f file: +test_data testsuite/libgomp.c/loop-2.c /^static void test_data (void)$/;" f file: +test_data testsuite/libgomp.c/ordered-1.c /^static void test_data (void)$/;" f file: +test_data testsuite/libgomp.c/sections-1.c /^static void test_data (void)$/;" f file: +test_do testsuite/libgomp.fortran/omp_parse1.f90 /^ subroutine test_do$/;" s +test_do_orphan testsuite/libgomp.fortran/omp_parse1.f90 /^ subroutine test_do_orphan$/;" s +test_flush testsuite/libgomp.fortran/omp_parse3.f90 /^ subroutine test_flush$/;" s +test_kernels testsuite/libgomp.oacc-c-c++-common/default-1.c /^int test_kernels ()$/;" f +test_master testsuite/libgomp.fortran/omp_parse2.f90 /^ subroutine test_master$/;" s +test_memcpy testsuite/libgomp.hsa.c/memory-operations-1.c /^test_memcpy (unsigned size)$/;" f file: +test_mempcpy testsuite/libgomp.hsa.c/memory-operations-1.c /^test_mempcpy (unsigned size)$/;" f file: +test_memset testsuite/libgomp.hsa.c/memory-operations-1.c /^test_memset (unsigned size)$/;" f file: +test_mod testsuite/libgomp.oacc-fortran/implicit-firstprivate-ref.f90 /^module test_mod$/;" m +test_nested testsuite/libgomp.c/target-20.c /^void test_nested ()$/;" f +test_nonstatic testsuite/libgomp.oacc-c-c++-common/gang-static-2.c /^test_nonstatic(int *a, int gangs)$/;" f +test_ordered testsuite/libgomp.fortran/omp_parse3.f90 /^ subroutine test_ordered$/;" s +test_parallel testsuite/libgomp.fortran/omp_parse1.f90 /^ subroutine test_parallel$/;" s +test_parallel testsuite/libgomp.oacc-c-c++-common/default-1.c /^int test_parallel ()$/;" f +test_reductions testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^test_reductions (void)$/;" f file: +test_reductions testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^test_reductions (void)$/;" f file: +test_reductions testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^test_reductions (void)$/;" f file: +test_reductions testsuite/libgomp.oacc-c-c++-common/reduction-4.c /^test_reductions (void)$/;" f file: +test_reductions_bool testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^test_reductions_bool (void)$/;" f file: +test_reductions_minmax testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^test_reductions_minmax (void)$/;" f file: +test_reductions_minmax testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^test_reductions_minmax (void)$/;" f file: +test_reductions_minmax testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^test_reductions_minmax (void)$/;" f file: +test_sections testsuite/libgomp.fortran/omp_parse1.f90 /^ subroutine test_sections$/;" s +test_single testsuite/libgomp.fortran/omp_parse1.f90 /^ subroutine test_single$/;" s +test_static testsuite/libgomp.oacc-c-c++-common/gang-static-2.c /^test_static(int *a, int num_gangs, int sarg)$/;" f +test_threadprivate testsuite/libgomp.fortran/omp_parse3.f90 /^ subroutine test_threadprivate$/;" s +test_tpf_static32 testsuite/libgomp.c/pr81875.c /^test_tpf_static32 (void)$/;" f +test_workshare testsuite/libgomp.fortran/omp_parse4.f90 /^ subroutine test_workshare$/;" s +tf testsuite/libgomp.c/icv-2.c /^void *tf (void *p)$/;" f +tf testsuite/libgomp.c/lock-3.c /^void *tf (void *p)$/;" f +tgt libgomp.h /^ struct target_mem_desc *tgt;$/;" m struct:gomp_target_task typeref:struct:gomp_target_task::target_mem_desc +tgt libgomp.h /^ struct target_mem_desc *tgt;$/;" m struct:splay_tree_key_s typeref:struct:splay_tree_key_s::target_mem_desc +tgt testsuite/libgomp.c/target-1.c /^tgt (void)$/;" f +tgt_end libgomp.h /^ uintptr_t tgt_end;$/;" m struct:target_mem_desc +tgt_fn plugin/plugin-hsa.c /^ void *tgt_fn;$/;" m struct:async_run_info file: +tgt_offset libgomp.h /^ uintptr_t tgt_offset;$/;" m struct:splay_tree_key_s +tgt_start libgomp.h /^ uintptr_t tgt_start;$/;" m struct:target_mem_desc +tgt_vars plugin/plugin-hsa.c /^ void *tgt_vars;$/;" m struct:async_run_info file: +tgtv testsuite/libgomp.c/target-1.c /^int tgtv = 6;$/;" v +thr testsuite/libgomp.c++/copyin-1.C /^int thr = 32;$/;" v +thr testsuite/libgomp.c++/copyin-2.C /^struct S { int t; char buf[64]; } thr = { 32, "" };$/;" v typeref:struct:S +thr testsuite/libgomp.c++/ctor-5.C /^static B thr;$/;" v file: +thr testsuite/libgomp.c/copyin-1.c /^int thr = 32;$/;" v +thr testsuite/libgomp.c/copyin-2.c /^struct { int t; char buf[64]; } thr = { 32, "" };$/;" v typeref:struct:__anon27 +thr testsuite/libgomp.c/copyin-3.c /^int thr;$/;" v +thr testsuite/libgomp.fortran/pointer2.f90 /^ integer, pointer, save :: thr(/;" v +thrc testsuite/libgomp.fortran/threadprivate2.f90 14;" c +thrc testsuite/libgomp.fortran/threadprivate3.f90 14;" c +thread_limit_var libgomp.h /^ unsigned int thread_limit_var;$/;" m struct:gomp_task_icv +thread_pool libgomp.h /^ struct gomp_thread_pool *thread_pool;$/;" m struct:gomp_thread typeref:struct:gomp_thread::gomp_thread_pool +thread_pool team.c /^ struct gomp_thread_pool *thread_pool;$/;" m struct:gomp_thread_start_data typeref:struct:gomp_thread_start_data::gomp_thread_pool file: +thread_pool_reservoir config/rtems/pool.h /^ struct gomp_thread_pool_reservoir *thread_pool_reservoir;$/;" m struct:gomp_tls_rtems_data typeref:struct:gomp_tls_rtems_data::gomp_thread_pool_reservoir +threadbase testsuite/libgomp.c++/ctor-10.C /^ static B *threadbase;$/;" m struct:B file: +threadbase testsuite/libgomp.c++/ctor-10.C /^B *B::threadbase;$/;" m class:B file: +threadbase testsuite/libgomp.c++/ctor-8.C /^static B *threadbase;$/;" v file: +threadbase testsuite/libgomp.c++/ctor-9.C /^static B *threadbase;$/;" v file: +threadprivate1 testsuite/libgomp.fortran/threadprivate1.f90 /^module threadprivate1$/;" m +threadprivate2 testsuite/libgomp.fortran/threadprivate2.f90 /^module threadprivate2$/;" m +threadprivate3 testsuite/libgomp.fortran/threadprivate3.f90 /^module threadprivate3$/;" m +threadprivate4 testsuite/libgomp.fortran/threadprivate4.f90 /^module threadprivate4$/;" m +threads libgomp.h /^ struct gomp_thread **threads;$/;" m struct:gomp_thread_pool typeref:struct:gomp_thread_pool::gomp_thread +threads_busy libgomp.h /^ unsigned long threads_busy;$/;" m struct:gomp_thread_pool +threads_completed libgomp.h /^ unsigned threads_completed;$/;" m struct:gomp_work_share +threads_dock libgomp.h /^ gomp_simple_barrier_t threads_dock;$/;" m struct:gomp_thread_pool +threads_size libgomp.h /^ unsigned threads_size;$/;" m struct:gomp_thread_pool +threads_used libgomp.h /^ unsigned threads_used;$/;" m struct:gomp_thread_pool +thrs testsuite/libgomp.c++/pr34513.C /^static int thrs = 4;$/;" v file: +thrs testsuite/libgomp.c/pr34513.c /^static int thrs = 4;$/;" v file: +thrv testsuite/libgomp.c/pr26171.c /^int thrv = 0;$/;" v +tiled_sgemm_tt testsuite/libgomp.hsa.c/tiling-1.c /^void tiled_sgemm_tt(const int M, const int N, const int K, const float alpha, const float*A, const int LDA,$/;" f +tiled_sgemm_tt testsuite/libgomp.hsa.c/tiling-2.c /^void tiled_sgemm_tt(const int M, const int N, const int K, const float alpha, const float*A, const int LDA,$/;" f +tlsblock testsuite/libgomp.fortran/omp_parse3.f90 4;" c +tlsblock testsuite/libgomp.fortran/omp_parse3.f90 56;" c subroutine:test_threadprivate +tn1 testsuite/libgomp.fortran/nested1.f90 /^ integer :: tn1,/;" v program:nested1 +tn2 testsuite/libgomp.fortran/nested1.f90 /^ integer :: tn1, tn2,/;" v program:nested1 +tn3 testsuite/libgomp.fortran/nested1.f90 /^ integer :: tn1, tn2, tn3$/;" v program:nested1 +to_free libgomp.h /^ void *to_free;$/;" m struct:target_mem_desc +to_free tdg.h /^ struct gomp_task *to_free;$/;" m struct:data_to_free typeref:struct:data_to_free::gomp_task +tol testsuite/libgomp.fortran/jacobi.f /^ double precision tol,/;" v program:main +top testsuite/libgomp.c/sort-1.c /^ struct int_pair *top;$/;" m struct:int_pair_stack typeref:struct:int_pair_stack::int_pair file: +total config/linux/bar.h /^ unsigned total __attribute__((aligned (64)));$/;" m struct:__anon42 +total config/nvptx/bar.h /^ unsigned total;$/;" m struct:__anon39 +total config/posix/bar.h /^ unsigned total;$/;" m struct:__anon35 +total config/rtems/bar.h /^ unsigned total __attribute__((aligned (64)));$/;" m struct:__anon43 +ts libgomp.h /^ struct gomp_team_state ts;$/;" m struct:gomp_thread typeref:struct:gomp_thread::gomp_team_state +ts team.c /^ struct gomp_team_state ts;$/;" m struct:gomp_thread_start_data typeref:struct:gomp_thread_start_data::gomp_team_state file: +type libgomp.h /^ enum offload_target_type type;$/;" m struct:gomp_device_descr typeref:enum:gomp_device_descr::offload_target_type +type plugin/plugin-nvptx.c /^ int type;$/;" m struct:ptx_event file: +type priority_queue.c /^ enum priority_queue_type type;$/;" m struct:cbtype typeref:enum:cbtype::priority_queue_type file: +type target.c /^ enum offload_target_type type;$/;" m struct:offload_image_descr typeref:enum:offload_image_descr::offload_target_type file: +typeX testsuite/libgomp.c++/declare_target-1.C /^struct typeX$/;" s file: +typeX testsuite/libgomp.c++/examples-4/declare_target-2.C /^struct typeX$/;" s file: +typeY testsuite/libgomp.c++/declare_target-1.C /^class typeY$/;" c file: +typeY testsuite/libgomp.c++/examples-4/declare_target-2.C /^class typeY$/;" c file: +u testsuite/libgomp.c++/simd-1.C /^struct U { U (); ~U (); int u; };$/;" m struct:U file: +u testsuite/libgomp.c++/simd-3.C /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +u testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +u testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" m struct:S file: +u testsuite/libgomp.c++/target-12.C /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +u testsuite/libgomp.c/atomic-6.c /^union { unsigned long long l; double d; } u = { .l = 0x7ff0000000072301ULL };$/;" v typeref:union:__anon26 +u testsuite/libgomp.c/pr66199-1.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-2.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-3.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-4.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-5.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-6.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-7.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-8.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/pr66199-9.c /^int u[1024], v[1024], w[1024];$/;" v +u testsuite/libgomp.c/simd-1.c /^struct U { int u; };$/;" m struct:U file: +u testsuite/libgomp.c/simd-10.c /^int s = 0, i, u;$/;" v +u testsuite/libgomp.c/simd-11.c /^int s = 0, i, j, u;$/;" v +u testsuite/libgomp.c/simd-3.c /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +u testsuite/libgomp.c/simd-7.c /^struct U { int u; };$/;" m struct:U file: +u testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +u testsuite/libgomp.c/target-22.c /^struct S { int *s; char *u; struct T v; short *w; };$/;" m struct:S file: +u testsuite/libgomp.c/target-23.c /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +u testsuite/libgomp.c/taskloop-2.c /^int u[1024], v[1024], w[1024], m;$/;" v +u testsuite/libgomp.c/taskloop-4.c /^int u[64], v;$/;" v +u testsuite/libgomp.fortran/pointer2.f90 /^ integer, target :: s(3), t(3), u(/;" v +u testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(/;" v +u testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(/;" v +u testsuite/libgomp.fortran/taskloop2.f90 /^ integer, save :: u(/;" v +u testsuite/libgomp.fortran/taskloop4.f90 /^ integer, save :: u(/;" v +u testsuite/libgomp.fortran/udr11.f90 /^ type(dt) :: j, k, l, m, n, o, p, q, r, s, t, u$/;" v +u2 testsuite/libgomp.c++/simd-3.C /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +u2 testsuite/libgomp.c/simd-3.c /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +u3 testsuite/libgomp.c++/simd-3.C /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +u3 testsuite/libgomp.c/simd-3.c /^__UINTPTR_TYPE__ u, u2, u3;$/;" v +uchar testsuite/libgomp.hsa.c/complex-1.c 5;" d file: +udr1 testsuite/libgomp.fortran/udr1.f90 /^module udr1$/;" m +udr10 testsuite/libgomp.fortran/udr10.f90 /^program udr10$/;" p +udr10m testsuite/libgomp.fortran/udr10.f90 /^module udr10m$/;" m +udr11 testsuite/libgomp.fortran/udr11.f90 /^module udr11$/;" m +udr15m1 testsuite/libgomp.fortran/udr15.f90 /^module udr15m1$/;" m +udr15m2 testsuite/libgomp.fortran/udr15.f90 /^module udr15m2$/;" m +udr2 testsuite/libgomp.fortran/udr2.f90 /^module udr2$/;" m +udr5 testsuite/libgomp.fortran/udr5.f90 /^program udr5$/;" p +udr6 testsuite/libgomp.fortran/udr6.f90 /^program udr6$/;" p +udr7 testsuite/libgomp.fortran/udr7.f90 /^program udr7$/;" p +udr8m1 testsuite/libgomp.fortran/udr8.f90 /^module udr8m1$/;" m +udr8m2 testsuite/libgomp.fortran/udr8.f90 /^module udr8m2$/;" m +udr9m1 testsuite/libgomp.fortran/udr9.f90 /^module udr9m1$/;" m +udr9m2 testsuite/libgomp.fortran/udr9.f90 /^module udr9m2$/;" m +unload_image_func libgomp.h /^ __typeof (GOMP_OFFLOAD_unload_image) *unload_image_func;$/;" m struct:gomp_device_descr +update testsuite/libgomp.oacc-fortran/update-1.f90 /^program update$/;" p +update_dev_host oacc-mem.c /^update_dev_host (int is_dev, void *h, size_t s)$/;" f file: +use testsuite/libgomp.c/target-31.c /^use (int *k, int *l, int *m, int *n, int *o, int *p, int *q, int *r)$/;" f +v testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +v testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +v testsuite/libgomp.c++/cancel-test.h /^ int v;$/;" m struct:S +v testsuite/libgomp.c++/loop-10.C /^int v;$/;" v +v testsuite/libgomp.c++/pr63248.C /^int *v;$/;" v +v testsuite/libgomp.c++/simd-1.C /^ int v;$/;" m struct:V file: +v testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +v testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" m struct:S file: +v testsuite/libgomp.c++/target-12.C /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +v testsuite/libgomp.c++/udr-3.C /^ int v;$/;" m struct:V file: +v testsuite/libgomp.c++/udr-3.C /^ int v;$/;" m struct:W file: +v testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +v testsuite/libgomp.c/loop-7.c /^int v;$/;" v +v testsuite/libgomp.c/monotonic-2.c /^volatile int v;$/;" v +v testsuite/libgomp.c/nonmonotonic-2.c /^volatile int v;$/;" v +v testsuite/libgomp.c/pr66199-1.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-2.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-3.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-4.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-5.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-6.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-7.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-8.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr66199-9.c /^int u[1024], v[1024], w[1024];$/;" v +v testsuite/libgomp.c/pr70680-1.c /^int v;$/;" v +v testsuite/libgomp.c/pr70680-2.c /^int v;$/;" v +v testsuite/libgomp.c/simd-1.c /^struct V { int v; };$/;" m struct:V file: +v testsuite/libgomp.c/simd-7.c /^struct V { int v; };$/;" m struct:V file: +v testsuite/libgomp.c/target-10.c /^int v;$/;" v +v testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S typeref:struct:S::T file: +v testsuite/libgomp.c/target-22.c /^struct S { int *s; char *u; struct T v; short *w; };$/;" m struct:S typeref:struct:S::T file: +v testsuite/libgomp.c/target-23.c /^struct S { int s; int *u; int v[5]; };$/;" m struct:S file: +v testsuite/libgomp.c/target-30.c /^int v = 6;$/;" v +v testsuite/libgomp.c/target-7.c /^volatile int v;$/;" v +v testsuite/libgomp.c/target-teams-1.c /^int v = 6;$/;" v +v testsuite/libgomp.c/taskgroup-1.c /^int v[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };$/;" v +v testsuite/libgomp.c/taskloop-2.c /^int u[1024], v[1024], w[1024], m;$/;" v +v testsuite/libgomp.c/taskloop-4.c /^int u[64], v;$/;" v +v testsuite/libgomp.fortran/associate1.f90 /^ integer :: v,/;" v program:associate1 +v testsuite/libgomp.fortran/associate2.f90 /^ integer :: v(/;" v program:associate2 +v testsuite/libgomp.fortran/associate3.f90 /^ type (t) :: v$/;" v +v testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(/;" v +v testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(/;" v +v testsuite/libgomp.fortran/reduction1.f90 /^ logical :: v$/;" v +v testsuite/libgomp.fortran/reduction2.f90 /^ logical :: l, la (4), m, ma (4), v$/;" v +v testsuite/libgomp.fortran/reduction3.f90 /^ logical :: v$/;" v +v testsuite/libgomp.fortran/reduction4.f90 /^ logical :: v$/;" v +v testsuite/libgomp.fortran/target1.f90 /^ double precision, pointer :: p(:), v(/;" v +v testsuite/libgomp.fortran/target6.f90 /^ double precision, pointer :: p(:), v(/;" v +v testsuite/libgomp.fortran/taskgroup1.f90 /^ integer :: v(/;" v +v testsuite/libgomp.fortran/taskloop2.f90 /^ integer, save/;" v +v testsuite/libgomp.fortran/taskloop4.f90 /^ integer, save/;" v +v1 testsuite/libgomp.c++/task-1.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v1 testsuite/libgomp.c++/task-6.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v1 testsuite/libgomp.c/examples-4/declare_target-3.c /^float p1[N], p2[N], v1[N], v2[N];$/;" v +v1 testsuite/libgomp.c/private-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v1 testsuite/libgomp.c/task-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v1 testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^ real :: p(N), v1(/;" v module:e_53_3_mod +v1 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ real, pointer, dimension(:) :: p1, p2, v1,/;" v program:e_50_4 +v1 testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ real, pointer, dimension(:) :: p, v1,/;" v program:e_51_4 +v1 testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ real, allocatable, dimension(:) :: p, v1,/;" v program:e_51_5 +v1 testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ real, pointer :: p(:), v1(/;" v program:e_52_1 +v1 testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ real, pointer :: p(:), v1(/;" v program:e_52_2 +v1 testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ real, pointer, dimension(:) :: p, v1,/;" v program:e_54_5 +v1 testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ real, pointer, dimension(:) :: p, v1,/;" v program:e_54_6 +v1 testsuite/libgomp.oacc-fortran/atomic_rw-1.f90 /^ integer v1,/;" v program:main +v1 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1,/;" v program:collapse5 +v1 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1,/;" v program:collapse6 +v1 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1,/;" v program:collapse8 +v2 testsuite/libgomp.c++/task-1.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v2 testsuite/libgomp.c++/task-6.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v2 testsuite/libgomp.c/examples-4/declare_target-3.c /^float p1[N], p2[N], v1[N], v2[N];$/;" v +v2 testsuite/libgomp.c/private-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v2 testsuite/libgomp.c/task-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v2 testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^ real :: p(N), v1(N), v2(/;" v module:e_53_3_mod +v2 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ real, pointer, dimension(:) :: p1, p2, v1, v2$/;" v program:e_50_4 +v2 testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ real, pointer, dimension(:) :: p, v1, v2$/;" v program:e_51_4 +v2 testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ real, allocatable, dimension(:) :: p, v1, v2$/;" v program:e_51_5 +v2 testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ real, pointer :: p(:), v1(:), v2(/;" v program:e_52_1 +v2 testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ real, pointer :: p(:), v1(:), v2(/;" v program:e_52_2 +v2 testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ real, pointer, dimension(:) :: p, v1, v2$/;" v program:e_54_5 +v2 testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ real, pointer, dimension(:) :: p, v1, v2$/;" v program:e_54_6 +v2 testsuite/libgomp.oacc-fortran/atomic_rw-1.f90 /^ integer v1, v2$/;" v program:main +v2 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1, v2,/;" v program:collapse5 +v2 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2,/;" v program:collapse6 +v2 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1, v2,/;" v program:collapse8 +v2k testsuite/libgomp.c/debug-1.c /^int v2k = 9;$/;" v +v3 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1, v2, v3,/;" v program:collapse5 +v3 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3,/;" v program:collapse6 +v3 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1, v2, v3,/;" v program:collapse8 +v4 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1, v2, v3, v4,/;" v program:collapse5 +v4 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4,/;" v program:collapse6 +v4 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1, v2, v3, v4,/;" v program:collapse8 +v4k testsuite/libgomp.c/debug-1.c /^int v4k = 9, v4l = 0;$/;" v +v4l testsuite/libgomp.c/debug-1.c /^int v4k = 9, v4l = 0;$/;" v +v5 testsuite/libgomp.c++/task-1.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v5 testsuite/libgomp.c++/task-6.C /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v5 testsuite/libgomp.c/private-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v5 testsuite/libgomp.c/task-1.c /^int v1 = 1, v2 = 2, v5 = 5;$/;" v +v5 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1, v2, v3, v4, v5,/;" v program:collapse5 +v5 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4, v5,/;" v program:collapse6 +v5 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1, v2, v3, v4, v5,/;" v program:collapse8 +v6 testsuite/libgomp.oacc-fortran/collapse-5.f90 /^ integer :: v1, v2, v3, v4, v5, v6$/;" v program:collapse5 +v6 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4, v5, v6,/;" v program:collapse6 +v6 testsuite/libgomp.oacc-fortran/collapse-8.f90 /^ integer :: v1, v2, v3, v4, v5, v6$/;" v program:collapse8 +v6k testsuite/libgomp.c/debug-1.c /^int v6k = 9, v6l = 0;$/;" v +v6l testsuite/libgomp.c/debug-1.c /^int v6k = 9, v6l = 0;$/;" v +v7 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4, v5, v6, v7,/;" v program:collapse6 +v8 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4, v5, v6, v7, v8,/;" v program:collapse6 +v9 testsuite/libgomp.oacc-fortran/collapse-6.f90 /^ integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9$/;" v program:collapse6 +v_p_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void v_p_1()$/;" f +v_p_2 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void v_p_2()$/;" f +val plugin/plugin-nvptx.c /^ int val;$/;" m struct:ptx_event file: +val testsuite/libgomp.c/cancel-taskgroup-1.c /^struct T { struct T *children[2]; int val; };$/;" m struct:T file: +value config/posix/sem.h /^ int value;$/;" m struct:gomp_sem +var testsuite/libgomp.fortran/threadprivate3.f90 /^ integer, dimension(2), target :: bar2, var$/;" v +var testsuite/libgomp.oacc-fortran/combined-reduction.f90 /^ integer i, n, var$/;" v program:test +var1 testsuite/libgomp.c/target-20.c /^int var1 = 1;$/;" v +var2 testsuite/libgomp.c/target-20.c /^int var2 = 2;$/;" v +varX testsuite/libgomp.c++/declare_target-1.C /^struct typeX varX;$/;" v typeref:struct:typeX +varX testsuite/libgomp.c++/examples-4/declare_target-2.C /^struct typeX varX;$/;" v typeref:struct:typeX +varY testsuite/libgomp.c++/declare_target-1.C /^class typeY varY;$/;" v typeref:class:typeY +varY testsuite/libgomp.c++/examples-4/declare_target-2.C /^class typeY varY;$/;" v typeref:class:typeY +var_names plugin/plugin-nvptx.c /^ const char *const *var_names;$/;" m struct:nvptx_tdata file: +var_num plugin/plugin-nvptx.c /^ unsigned var_num;$/;" m struct:nvptx_tdata file: +var_x testsuite/libgomp.fortran/declare-target-1.f90 /^ integer :: var_x$/;" v module:declare_target_1_mod +vars testsuite/libgomp.oacc-fortran/declare-1.f90 /^module vars$/;" m +vars testsuite/libgomp.oacc-fortran/declare-4.f90 /^module vars$/;" m +vars testsuite/libgomp.oacc-fortran/declare-5.f90 /^module vars$/;" m +vec2 testsuite/libgomp.oacc-c-c++-common/private-variables.c /^} vec2;$/;" t typeref:struct:__anon24 file: +vec2 testsuite/libgomp.oacc-fortran/private-variables.f90 /^ type vec2$/;" t subroutine:t12 +vec3 testsuite/libgomp.oacc-fortran/private-variables.f90 /^ type vec3$/;" t subroutine:t4 +vec3_attr testsuite/libgomp.oacc-c-c++-common/private-variables.c /^} vec3_attr;$/;" t typeref:struct:__anon25 file: +vec_mult testsuite/libgomp.c++/examples-4/target_data-5.C /^void vec_mult (float *&p, float *&v1, float *&v2, int n)$/;" f +vec_mult testsuite/libgomp.c/examples-4/async_target-2.c /^void vec_mult(float *p, int n)$/;" f +vec_mult testsuite/libgomp.c/examples-4/declare_target-3.c /^void vec_mult ()$/;" f +vec_mult testsuite/libgomp.c/examples-4/target-1.c /^void vec_mult (int *p)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target-2.c /^void vec_mult (char *p)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target-3.c /^void vec_mult (long long *p)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target-4.c /^void vec_mult (double *p, double *v1, double *v2)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target-5.c /^void vec_mult (float *p, float *v1, float *v2)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_data-1.c /^void vec_mult (long long *p, long long *v1, long long *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_data-2.c /^void vec_mult (char *p, char *v1, char *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_data-4.c /^void vec_mult (double *p1, double *v3, double *v4, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_data-6.c /^void vec_mult (float *p, float *v1, float *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_data-7.c /^void vec_mult (short *p, short *v1, short *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_update-1.c /^void vec_mult (int *p, int *v1, int *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/target_update-2.c /^void vec_mult (int *p, int *v1, int *v2, int N)$/;" f +vec_mult testsuite/libgomp.c/examples-4/teams-5.c /^void vec_mult (float *p, float *v1, float *v2, int n)$/;" f +vec_mult testsuite/libgomp.c/examples-4/teams-6.c /^void vec_mult (float *p, float *v1, float *v2, int n)$/;" f +vec_mult testsuite/libgomp.fortran/examples-4/async_target-2.f90 /^subroutine vec_mult /;" s +vec_mult testsuite/libgomp.fortran/examples-4/declare_target-3.f90 /^subroutine vec_mult /;" s +vec_mult testsuite/libgomp.fortran/examples-4/target-1.f90 /^ subroutine vec_mult /;" s module:e_50_1_mod +vec_mult testsuite/libgomp.fortran/examples-4/target-2.f90 /^ subroutine vec_mult /;" s module:e_50_2_mod +vec_mult testsuite/libgomp.fortran/examples-4/target-3.f90 /^ subroutine vec_mult /;" s module:e_50_3_mod +vec_mult testsuite/libgomp.fortran/examples-4/target-5.f90 /^ subroutine vec_mult /;" s module:e_50_5_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-1.f90 /^ subroutine vec_mult /;" s module:e_51_1_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-2.f90 /^ subroutine vec_mult /;" s module:e_51_2_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-4.f90 /^ subroutine vec_mult /;" s module:e_51_4_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-5.f90 /^ subroutine vec_mult /;" s module:e_51_5_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-6.f90 /^ subroutine vec_mult /;" s module:e_51_6_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_data-7.f90 /^ subroutine vec_mult /;" s module:e_51_7_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_update-1.f90 /^ subroutine vec_mult /;" s module:e_52_1_mod +vec_mult testsuite/libgomp.fortran/examples-4/target_update-2.f90 /^ subroutine vec_mult /;" s module:e_52_2_mod +vec_mult testsuite/libgomp.fortran/examples-4/teams-5.f90 /^ subroutine vec_mult /;" s module:e_54_5_mod +vec_mult testsuite/libgomp.fortran/examples-4/teams-6.f90 /^ subroutine vec_mult /;" s module:e_54_6_mod +vec_mult_1 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ subroutine vec_mult_1 /;" s module:e_50_4_mod +vec_mult_2 testsuite/libgomp.fortran/examples-4/target-4.f90 /^ subroutine vec_mult_2 /;" s module:e_50_4_mod +vec_mult_ref testsuite/libgomp.c++/examples-4/target_data-5.C /^void vec_mult_ref (float *&p, float *&v1, float *&v2, int n)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/async_target-2.c /^void vec_mult_ref(float *p, int n)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/declare_target-3.c /^void vec_mult_ref ()$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target-1.c /^void vec_mult_ref (int *p)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target-2.c /^void vec_mult_ref (char *p)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target-3.c /^void vec_mult_ref (long long *p)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target-4.c /^void vec_mult_ref (double *p, double *v1, double *v2)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target-5.c /^void vec_mult_ref (float *p, float *v1, float *v2)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_data-1.c /^void vec_mult_ref (long long *p, long long *v1, long long *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_data-2.c /^void vec_mult_ref (char *p, char *v1, char *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_data-4.c /^void vec_mult_ref (double *p1, double *v3, double *v4, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_data-6.c /^void vec_mult_ref (float *p, float *v1, float *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_data-7.c /^void vec_mult_ref (short *p, short *v1, short *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_update-1.c /^void vec_mult_ref (int *p, int *v1, int *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/target_update-2.c /^void vec_mult_ref (int *p, int *v1, int *v2, int N)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/teams-5.c /^void vec_mult_ref (float *p, float *v1, float *v2, int n)$/;" f +vec_mult_ref testsuite/libgomp.c/examples-4/teams-6.c /^void vec_mult_ref (float *p, float *v1, float *v2, int n)$/;" f +vector testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^vector (Type ary[N], Type sum, Type prod)$/;" f file: +vector testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^vector (Type ary[N], Type sum, Type prod)$/;" f file: +vector testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^vector (Type ary[N], Type sum, Type prod)$/;" f file: +vector testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^vector (Type ary[N], Type sum, Type prod)$/;" f file: +vector testsuite/libgomp.oacc-c-c++-common/routine-4.c /^vector (int *a)$/;" f +vector testsuite/libgomp.oacc-c-c++-common/routine-v-1.c /^void __attribute__ ((noinline)) vector (int ary[N])$/;" f +vector testsuite/libgomp.oacc-c-c++-common/vector-type-1.c 1;" d file: +vector testsuite/libgomp.oacc-fortran/routine-7.f90 /^subroutine vector /;" s program:main +vector_1 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int vector_1 (int *ary, int size)$/;" f +vector_2 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int vector_2 (int *ary, int size)$/;" f +ver_dl testsuite/libgomp.fortran/alloc-comp-1.f90 /^ subroutine ver_dl /;" s module:m +ver_dl testsuite/libgomp.fortran/alloc-comp-2.f90 /^ subroutine ver_dl /;" s module:m +ver_dl testsuite/libgomp.fortran/alloc-comp-3.f90 /^ subroutine ver_dl /;" s module:m +ver_dt testsuite/libgomp.fortran/alloc-comp-1.f90 /^ subroutine ver_dt /;" s module:m +ver_dt testsuite/libgomp.fortran/alloc-comp-2.f90 /^ subroutine ver_dt /;" s module:m +ver_dt testsuite/libgomp.fortran/alloc-comp-3.f90 /^ subroutine ver_dt /;" s module:m +verify testsuite/libgomp.c++/cancel-test.h /^ verify ()$/;" f struct:S +verify testsuite/libgomp.c/affinity-1.c 245;" d file: +verify testsuite/libgomp.c/sort-1.c /^verify (const char *name, double stime, int *array, int count)$/;" f file: +verify testsuite/libgomp.hsa.c/switch-sbr-2.c /^verify(int *a)$/;" f +verify testsuite/libgomp.hsa.c/tiling-1.c /^int verify(float* v_res, float* v_ref, int len) {$/;" f +verify testsuite/libgomp.hsa.c/tiling-2.c /^int verify(float* v_res, float* v_ref, int len) {$/;" f +version openacc_lib.h /^! the Free Software Foundation; either version 3, or (at your option)$/;" v +version target.c /^ unsigned version;$/;" m struct:offload_image_descr file: +version_func libgomp.h /^ __typeof (GOMP_OFFLOAD_version) *version_func;$/;" m struct:gomp_device_descr +vfprintf config/nvptx/error.c 34;" d file: +vfprintf config/nvptx/error.c 38;" d file: +vi testsuite/libgomp.fortran/threadprivate4.f90 /^ integer :: vi$/;" v module:threadprivate4 +vl testsuite/libgomp.oacc-c-c++-common/reduction-1.c /^const int vl = 32;$/;" v +vl testsuite/libgomp.oacc-c-c++-common/reduction-2.c /^const int vl = 32;$/;" v +vl testsuite/libgomp.oacc-c-c++-common/reduction-3.c /^const int vl = 32;$/;" v +vl testsuite/libgomp.oacc-c-c++-common/reduction-4.c /^const int vl = 32;$/;" v +vl testsuite/libgomp.oacc-c-c++-common/reduction-5.c /^const int vl = 32;$/;" v +vl testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer, parameter :: n = 10, ng = 8, nw = 4, vl /;" v program:reduction_1 +vl testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ integer, parameter :: n = 10, ng = 8, nw = 4, vl /;" v program:reduction_2 +vl testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ integer, parameter :: n = 10, ng = 8, nw = 4, vl /;" v program:reduction_3 +vl testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ integer, parameter :: n = 10, ng = 8, nw = 4, vl /;" v program:reduction_4 +vred testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: j, red, vred$/;" v program:reduction +vresult testsuite/libgomp.oacc-fortran/reduction-1.f90 /^ integer :: i, vresult,/;" v program:reduction_1 +vresult testsuite/libgomp.oacc-fortran/reduction-2.f90 /^ real :: vresult,/;" v program:reduction_2 +vresult testsuite/libgomp.oacc-fortran/reduction-3.f90 /^ double precision :: vresult,/;" v program:reduction_3 +vresult testsuite/libgomp.oacc-fortran/reduction-4.f90 /^ real :: vresult,/;" v program:reduction_4 +vs testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsu/;" v program:reduction +vs1 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1,/;" v program:reduction +vs2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2, vs1, vs2,/;" v program:reduction +vsum testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsum,/;" v program:reduction +vsum testsuite/libgomp.oacc-fortran/reduction-7.f90 /^ integer :: i, j, vsum,/;" v program:reduction +w testsuite/libgomp.c++/reduction-10.C /^ B (&w)[1][N];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-11.C /^ long (&w)[1][2];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-12.C /^ B (&w)[1][N];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-5.C /^ long (&w)[1][2];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-6.C /^ B (&w)[1][2];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-7.C /^ long (&w)[1][2];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-8.C /^ B (&w)[1][2];$/;" m struct:S file: +w testsuite/libgomp.c++/reduction-9.C /^ long (&w)[1][N];$/;" m struct:S file: +w testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S typeref:union:S::U file: +w testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" m struct:S file: +w testsuite/libgomp.c/pr66199-1.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-2.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-3.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-4.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-5.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-6.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-7.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-8.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/pr66199-9.c /^int u[1024], v[1024], w[1024];$/;" v +w testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S typeref:union:S::U file: +w testsuite/libgomp.c/target-22.c /^struct S { int *s; char *u; struct T v; short *w; };$/;" m struct:S file: +w testsuite/libgomp.c/taskloop-2.c /^int u[1024], v[1024], w[1024], m;$/;" v +w testsuite/libgomp.fortran/pr66199-1.f90 /^ integer :: u(1024), v(1024), w(/;" v +w testsuite/libgomp.fortran/pr66199-2.f90 /^ integer :: u(1024), v(1024), w(/;" v +w testsuite/libgomp.fortran/target1.f90 /^ double precision, pointer :: p(:), v(:), w(/;" v +w testsuite/libgomp.fortran/target6.f90 /^ double precision, pointer :: p(:), v(:), w(/;" v +w testsuite/libgomp.fortran/taskloop2.f90 /^ integer, save :: u(1024), v(1024), w(/;" v +w3 testsuite/libgomp.c++/reduction-10.C /^B w3[1][2];$/;" v +w3 testsuite/libgomp.c++/reduction-11.C /^long w3[1][2] = { ~0L, ~0L };$/;" v +w3 testsuite/libgomp.c++/reduction-12.C /^B w3[1][2];$/;" v +w3 testsuite/libgomp.c++/reduction-5.C /^long w3[1][2] = { ~0L, ~0L };$/;" v +w3 testsuite/libgomp.c++/reduction-6.C /^B w3[1][2];$/;" v +w3 testsuite/libgomp.c++/reduction-7.C /^long w3[1][2] = { ~0L, ~0L };$/;" v +w3 testsuite/libgomp.c++/reduction-8.C /^B w3[1][2];$/;" v +w3 testsuite/libgomp.c++/reduction-9.C /^long w3[1][2] = { ~0L, ~0L };$/;" v +w_p_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void w_p_1()$/;" f +wdims plugin/plugin-hsa.c /^ uint32_t wdims[3];$/;" m struct:GOMP_kernel_launch_attributes file: +width plugin/hsa_ext_finalize.h /^ size_t width;$/;" m struct:hsa_ext_image_descriptor_s +width testsuite/libgomp.hsa.c/tiling-1.c /^ int width;$/;" m struct:__anon23 file: +width testsuite/libgomp.hsa.c/tiling-2.c /^ int width;$/;" m struct:__anon22 file: +work testsuite/libgomp.c/appendix-a/a.15.1.c /^work (int n)$/;" f +work testsuite/libgomp.c/appendix-a/a.18.1.c /^int work[NUMBER_OF_THREADS];$/;" v +work testsuite/libgomp.c/appendix-a/a.21.1.c /^work (int k)$/;" f +work testsuite/libgomp.c/appendix-a/a.39.1.c /^work (int i)$/;" f +work testsuite/libgomp.c/examples-4/simd-2.c /^void work( double *a, double *b, int n )$/;" f +work testsuite/libgomp.c/examples-4/simd-3.c /^double work( double *a, double *b, int n )$/;" f +work testsuite/libgomp.c/examples-4/simd-4.c /^void work( double *b, int n, int m )$/;" f +work testsuite/libgomp.c/examples-4/simd-5.c /^void work( double a[N][N], double b[N][N], double c[N][N], int n )$/;" f +work testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ subroutine work(/;" s module:SIMD2_mod +work testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ subroutine work(/;" s module:SIMD3_mod +work testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ subroutine work(/;" s module:SIMD4_mod +work testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ subroutine work(/;" s module:SIMD5_mod +work testsuite/libgomp.fortran/examples-4/simd-8.f90 /^module work$/;" m +work1 testsuite/libgomp.c/appendix-a/a.16.1.c /^work1 (int i)$/;" f +work2 testsuite/libgomp.c/appendix-a/a.16.1.c /^work2 (int i)$/;" f +work_ref testsuite/libgomp.c/examples-4/simd-2.c /^void work_ref( double *a, double *b, int n )$/;" f +work_ref testsuite/libgomp.c/examples-4/simd-3.c /^double work_ref( double *a, double *b, int n )$/;" f +work_ref testsuite/libgomp.c/examples-4/simd-4.c /^void work_ref( double *b, int n, int m )$/;" f +work_ref testsuite/libgomp.c/examples-4/simd-5.c /^void work_ref( double a[N][N], double b[N][N], double c[N][N], int n )$/;" f +work_ref testsuite/libgomp.fortran/examples-4/simd-2.f90 /^ subroutine work_ref(/;" s module:SIMD2_mod +work_ref testsuite/libgomp.fortran/examples-4/simd-3.f90 /^ subroutine work_ref(/;" s module:SIMD3_mod +work_ref testsuite/libgomp.fortran/examples-4/simd-4.f90 /^ subroutine work_ref(/;" s module:SIMD4_mod +work_ref testsuite/libgomp.fortran/examples-4/simd-5.f90 /^ subroutine work_ref(/;" s module:SIMD5_mod +work_share libgomp.h /^ struct gomp_work_share *work_share;$/;" m struct:gomp_team_state typeref:struct:gomp_team_state::gomp_work_share +work_share_cancelled libgomp.h /^ int work_share_cancelled;$/;" m struct:gomp_team +work_share_chunk libgomp.h /^ unsigned work_share_chunk;$/;" m struct:gomp_team +work_share_list_alloc libgomp.h /^ struct gomp_work_share *work_share_list_alloc;$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_work_share +work_share_list_free libgomp.h /^ struct gomp_work_share *work_share_list_free;$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_work_share +work_share_list_free_lock libgomp.h /^ gomp_mutex_t work_share_list_free_lock;$/;" m struct:gomp_team +work_shares libgomp.h /^ struct gomp_work_share work_shares[8];$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_work_share +work_shares_to_free libgomp.h /^ struct gomp_work_share *work_shares_to_free;$/;" m struct:gomp_team typeref:struct:gomp_team::gomp_work_share +worker testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c /^worker (Type ary[N], Type sum, Type prod)$/;" f file: +worker testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c /^worker (Type ary[N], Type sum, Type prod)$/;" f file: +worker testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c /^worker (Type ary[N], Type sum, Type prod)$/;" f file: +worker testsuite/libgomp.oacc-c-c++-common/reduction-flt.c /^worker (Type ary[N], Type sum, Type prod)$/;" f file: +worker testsuite/libgomp.oacc-c-c++-common/routine-4.c /^worker (int *b)$/;" f +worker testsuite/libgomp.oacc-c-c++-common/routine-w-1.c /^void __attribute__ ((noinline)) worker (int ary[N])$/;" f +worker testsuite/libgomp.oacc-c-c++-common/routine-wv-1.c /^void __attribute__ ((noinline)) worker (int ary[N])$/;" f +worker testsuite/libgomp.oacc-fortran/routine-7.f90 /^subroutine worker /;" s program:main +worker_1 testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c /^int worker_1 (int *ary, int size)$/;" f +worker_matmul testsuite/libgomp.oacc-c-c++-common/crash-1.c /^worker_matmul (int *c, int i)$/;" f +worker_vector_2a testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int worker_vector_2a (int *ary, int size)$/;" f +worker_vector_2b testsuite/libgomp.oacc-c-c++-common/tile-1.c /^int worker_vector_2b (int *ary, int size)$/;" f +ws testsuite/libgomp.oacc-fortran/reduction-5.f90 /^ integer :: i, vsum, gs, ws,/;" v program:reduction +ws1 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1,/;" v program:reduction +ws2 testsuite/libgomp.oacc-fortran/reduction-6.f90 /^ integer :: i, gs1, gs2, ws1, ws2,/;" v program:reduction +wv_p_1 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void wv_p_1()$/;" f +wv_p_2 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void wv_p_2()$/;" f +wv_p_3 testsuite/libgomp.oacc-c-c++-common/reduction-7.c /^void wv_p_3()$/;" f +x testsuite/libgomp.c++/atomic-10.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-11.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-12.C /^int x = 6, cnt;$/;" v +x testsuite/libgomp.c++/atomic-13.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-14.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-15.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-2.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-4.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/atomic-8.C /^int x = 6, cnt;$/;" v +x testsuite/libgomp.c++/atomic-9.C /^int x = 6;$/;" v +x testsuite/libgomp.c++/pr26943.C /^ int x;$/;" m struct:S file: +x testsuite/libgomp.c++/pr26943.C /^static S x;$/;" v file: +x testsuite/libgomp.c++/pr27337.C /^S x;$/;" v +x testsuite/libgomp.c++/reduction-10.C /^ A (*&x)[3][N];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-11.C /^ int (*&x)[3][2];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-12.C /^ A (*&x)[3][N];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-5.C /^ int (*&x)[3][2];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-6.C /^ A (*&x)[3][2];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-7.C /^ int (*&x)[3][2];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-8.C /^ A (*&x)[3][2];$/;" m struct:S file: +x testsuite/libgomp.c++/reduction-9.C /^ int (*&x)[3][N];$/;" m struct:S file: +x testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +x testsuite/libgomp.c++/target-10.C /^union U { int x; long long y; };$/;" m union:U file: +x testsuite/libgomp.c++/target-11.C /^struct S { int *s; char *u; T v; short *w; short *&x; };$/;" m struct:S file: +x testsuite/libgomp.c++/target-14.C /^int x;$/;" v +x testsuite/libgomp.c++/target-21.C /^struct S { int (&x)[10]; int *&y; T t; int &z; S (); ~S (); };$/;" m struct:S file: +x testsuite/libgomp.c/appendix-a/a.19.1.c /^int x, *p = &x;$/;" v +x testsuite/libgomp.c/atomic-1.c /^} x;$/;" v typeref:struct:__anon29 +x testsuite/libgomp.c/atomic-11.c /^int x = 6;$/;" v +x testsuite/libgomp.c/atomic-14.c /^int x = 6, cnt;$/;" v +x testsuite/libgomp.c/atomic-15.c /^int x = 6;$/;" v +x testsuite/libgomp.c/atomic-16.c /^int x = 6, cnt;$/;" v +x testsuite/libgomp.c/atomic-17.c /^int x = 6;$/;" v +x testsuite/libgomp.c/pr61200.c /^volatile int x;$/;" v +x testsuite/libgomp.c/pr66133.c /^volatile int x;$/;" v +x testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +x testsuite/libgomp.c/target-21.c /^union U { int x; long long y; };$/;" m union:U file: +x testsuite/libgomp.c/uns-outer-4.c /^unsigned int x[500][500];$/;" v +x testsuite/libgomp.fortran/cancel-do-2.f90 /^ logical :: x(/;" v +x testsuite/libgomp.fortran/cancel-parallel-3.f90 /^ integer :: x,/;" v +x testsuite/libgomp.fortran/cancel-parallel-3.f90 33;" c subroutine:do_some_work +x testsuite/libgomp.fortran/cancel-parallel-3.f90 7;" c +x testsuite/libgomp.fortran/depend-2.f90 /^ integer :: x(/;" v +x testsuite/libgomp.fortran/depend-3.f90 /^ integer :: x(/;" v +x testsuite/libgomp.fortran/examples-4/declare_target-2.f90 /^ integer :: x,/;" v program:e_53_2 +x testsuite/libgomp.fortran/examples-4/task_dep-1.f90 /^ integer :: x$/;" v program:example +x testsuite/libgomp.fortran/examples-4/task_dep-2.f90 /^ integer :: x$/;" v program:example +x testsuite/libgomp.fortran/examples-4/task_dep-3.f90 /^ integer :: x$/;" v program:example +x testsuite/libgomp.fortran/examples-4/task_dep-4.f90 /^ integer :: x$/;" v program:example +x testsuite/libgomp.fortran/omp_parse3.f90 /^ integer :: x,/;" v +x testsuite/libgomp.fortran/pr63938-1.f90 /^ integer :: i, x(/;" v program:pr63938_1 +x testsuite/libgomp.fortran/pr63938-2.f90 /^ integer :: x$/;" k type:t +x testsuite/libgomp.fortran/pr63938-2.f90 /^ type(t) :: x$/;" v program:pr63938_2 +x testsuite/libgomp.fortran/reduction4.f90 /^ integer (kind = 4) :: i, ia (6), j, ja (6), k, ka (6), ta (6), n, cnt, x$/;" v +x testsuite/libgomp.fortran/simd1.f90 /^ integer :: x /;" k type:dt +x testsuite/libgomp.fortran/udr1.f90 /^ integer :: x /;" k type:dt +x testsuite/libgomp.fortran/udr10.f90 /^ integer :: x /;" k type:dt +x testsuite/libgomp.fortran/udr11.f90 /^ integer :: x /;" k type:dt +x testsuite/libgomp.fortran/udr15.f90 /^ integer :: x$/;" k type:dt +x testsuite/libgomp.fortran/udr2.f90 /^ integer :: x /;" k type:dt +x testsuite/libgomp.fortran/udr7.f90 /^ real :: x /;" v program:udr7 +x testsuite/libgomp.fortran/udr8.f90 /^ integer :: x$/;" k type:dt +x testsuite/libgomp.fortran/udr9.f90 /^ integer :: x$/;" k type:dt +x testsuite/libgomp.graphite/force-parallel-1.c /^int x[10000000];$/;" v +x testsuite/libgomp.graphite/force-parallel-8.c /^int x[N][N], y[N];$/;" v +x testsuite/libgomp.hsa.c/formal-actual-args-1.c /^ int x;$/;" m struct:Cube file: +x testsuite/libgomp.oacc-c-c++-common/lib-88.c /^unsigned char *x;$/;" v +x testsuite/libgomp.oacc-c-c++-common/lib-89.c /^unsigned char **x;$/;" v +x testsuite/libgomp.oacc-c-c++-common/lib-90.c /^unsigned char **x;$/;" v +x testsuite/libgomp.oacc-c-c++-common/lib-92.c /^unsigned char **x;$/;" v +x testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int x, y, z;$/;" m struct:__anon25 file: +x testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int x, y;$/;" m struct:__anon24 file: +x testsuite/libgomp.oacc-fortran/atomic_rw-1.f90 /^ integer x$/;" v program:main +x testsuite/libgomp.oacc-fortran/gang-static-1.f90 /^ integer x$/;" v program:main +x testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x,/;" k type:vec2 +x testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x,/;" k type:vec3 +x1 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x1 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x1 testsuite/libgomp.c/atomic-10.c /^int x1, x2, x3, x4, x5;$/;" v +x1 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x2 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x2 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x2 testsuite/libgomp.c/atomic-10.c /^int x1, x2, x3, x4, x5;$/;" v +x2 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x3 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x3 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x3 testsuite/libgomp.c/atomic-10.c /^int x1, x2, x3, x4, x5;$/;" v +x3 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x4 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x4 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x4 testsuite/libgomp.c/atomic-10.c /^int x1, x2, x3, x4, x5;$/;" v +x4 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x5 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x5 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x5 testsuite/libgomp.c/atomic-10.c /^int x1, x2, x3, x4, x5;$/;" v +x5 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x6 testsuite/libgomp.c++/atomic-3.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x6 testsuite/libgomp.c++/atomic-5.C /^bool v, x1, x2, x3, x4, x5, x6;$/;" v +x6 testsuite/libgomp.c/atomic-12.c /^_Bool v, x1, x2, x3, x4, x5, x6;$/;" v +x_max testsuite/libgomp.oacc-fortran/pr70643.f90 /^ integer :: x_min,x_max,/;" v program:main +x_min testsuite/libgomp.oacc-fortran/implicit-firstprivate-ref.f90 /^ INTEGER :: x_min$/;" v program:t +x_min testsuite/libgomp.oacc-fortran/pr70643.f90 /^ integer :: x_min,/;" v program:main +xc testsuite/libgomp.c++/ctor-13.C /^ static int ic, dc, xc, ac, cc;$/;" m struct:B file: +xc testsuite/libgomp.c++/ctor-13.C /^int B::xc;$/;" m class:B file: +xcount testsuite/libgomp.c++/ctor-1.C /^ static int xcount;$/;" m struct:B file: +xcount testsuite/libgomp.c++/ctor-1.C /^int B::xcount;$/;" m class:B file: +xcount testsuite/libgomp.c++/ctor-11.C /^ static int xcount;$/;" m struct:B file: +xcount testsuite/libgomp.c++/ctor-11.C /^int B::xcount;$/;" m class:B file: +xcount testsuite/libgomp.c++/ctor-2.C /^ static int xcount;$/;" m struct:B file: +xcount testsuite/libgomp.c++/ctor-2.C /^int B::xcount;$/;" m class:B file: +xcount testsuite/libgomp.c++/ctor-7.C /^ static int xcount;$/;" m struct:B file: +xcount testsuite/libgomp.c++/ctor-7.C /^int B::xcount;$/;" m class:B file: +xdt testsuite/libgomp.fortran/udr5.f90 /^ type(dt) :: xdt,/;" v program:udr5 +xdt testsuite/libgomp.fortran/udr6.f90 /^ type(dt), allocatable :: xdt(/;" v program:udr6 +xt testsuite/libgomp.c++/target-21.C /^int xt[10] = { 1, 2, 28, 3, 4, 5, 6, 7, 8, 9 };$/;" v +y testsuite/libgomp.c++/atomic-2.C /^float y;$/;" v +y testsuite/libgomp.c++/atomic-4.C /^float y;$/;" v +y testsuite/libgomp.c++/reduction-10.C /^ M *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-11.C /^ int *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-12.C /^ M *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-5.C /^ int *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-6.C /^ M *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-7.C /^ int *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-8.C /^ M *y;$/;" m struct:S file: +y testsuite/libgomp.c++/reduction-9.C /^ int *y;$/;" m struct:S file: +y testsuite/libgomp.c++/shared-1.C /^ struct Y y;$/;" m struct:X typeref:struct:X::Y file: +y testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +y testsuite/libgomp.c++/target-10.C /^union U { int x; long long y; };$/;" m union:U file: +y testsuite/libgomp.c++/target-21.C /^struct S { int (&x)[10]; int *&y; T t; int &z; S (); ~S (); };$/;" m struct:S file: +y testsuite/libgomp.c/atomic-11.c /^float y;$/;" v +y testsuite/libgomp.c/shared-1.c /^ struct Y y;$/;" m struct:X typeref:struct:X::Y file: +y testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +y testsuite/libgomp.c/target-21.c /^union U { int x; long long y; };$/;" m union:U file: +y testsuite/libgomp.fortran/alloc-comp-1.f90 /^ typ/;" v +y testsuite/libgomp.fortran/alloc-comp-2.f90 /^ typ/;" v +y testsuite/libgomp.fortran/alloc-comp-3.f90 /^ typ/;" v +y testsuite/libgomp.fortran/depend-2.f90 /^ integer :: x(3:6, 7:12), y$/;" v +y testsuite/libgomp.fortran/omp_parse3.f90 /^ integer :: x, y,/;" v +y testsuite/libgomp.fortran/udr1.f90 /^ integer :: y /;" k type:dt +y testsuite/libgomp.fortran/udr2.f90 /^ integer :: y /;" k type:dt +y testsuite/libgomp.graphite/force-parallel-8.c /^int x[N][N], y[N];$/;" v +y testsuite/libgomp.hsa.c/formal-actual-args-1.c /^ int y;$/;" m struct:Cube file: +y testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int x, y, z;$/;" m struct:__anon25 file: +y testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int x, y;$/;" m struct:__anon24 file: +y testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x, y$/;" k type:vec2 +y testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x, y,/;" k type:vec3 +y2 testsuite/libgomp.c/atomic-10.c /^volatile int y6 = 9, y2, y3, y4, y5;$/;" v +y3 testsuite/libgomp.c++/reduction-10.C /^M y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-11.C /^int y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-12.C /^M y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-5.C /^int y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-6.C /^M y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-7.C /^int y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-8.C /^M y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c++/reduction-9.C /^int y3[5] = { 0, 1, 1, 1, 0 };$/;" v +y3 testsuite/libgomp.c/atomic-10.c /^volatile int y6 = 9, y2, y3, y4, y5;$/;" v +y4 testsuite/libgomp.c/atomic-10.c /^volatile int y6 = 9, y2, y3, y4, y5;$/;" v +y5 testsuite/libgomp.c/atomic-10.c /^volatile int y6 = 9, y2, y3, y4, y5;$/;" v +y6 testsuite/libgomp.c/atomic-10.c /^volatile int y6 = 9, y2, y3, y4, y5;$/;" v +y_max testsuite/libgomp.oacc-fortran/pr70643.f90 /^ integer :: x_min,x_max,y_min,y_max$/;" v program:main +y_min testsuite/libgomp.oacc-fortran/pr70643.f90 /^ integer :: x_min,x_max,y_min,/;" v program:main +yp testsuite/libgomp.c++/target-21.C /^int *yp = yt;$/;" v +yt testsuite/libgomp.c++/target-21.C /^int yt[10] = { 1, 2, 37, 3, 4, 5, 6, 7, 8, 9 };$/;" v +z testsuite/libgomp.c++/pr39573.C /^int z;$/;" v +z testsuite/libgomp.c++/reduction-10.C /^ A z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-10.C /^A z[10];$/;" v +z testsuite/libgomp.c++/reduction-11.C /^ char z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-11.C /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c++/reduction-12.C /^ A z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-12.C /^A z[10];$/;" v +z testsuite/libgomp.c++/reduction-5.C /^ char z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-5.C /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c++/reduction-6.C /^ A z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-6.C /^A z[10];$/;" v +z testsuite/libgomp.c++/reduction-7.C /^ char z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-7.C /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c++/reduction-8.C /^ A z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-8.C /^A z[10];$/;" v +z testsuite/libgomp.c++/reduction-9.C /^ char z[10];$/;" m struct:S file: +z testsuite/libgomp.c++/reduction-9.C /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c++/target-10.C /^struct S { int s; int u; T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +z testsuite/libgomp.c++/target-10.C /^volatile int z;$/;" v +z testsuite/libgomp.c++/target-11.C /^volatile int z;$/;" v +z testsuite/libgomp.c++/target-12.C /^volatile int z;$/;" v +z testsuite/libgomp.c++/target-21.C /^struct S { int (&x)[10]; int *&y; T t; int &z; S (); ~S (); };$/;" m struct:S file: +z testsuite/libgomp.c/reduction-10.c /^struct B z[10];$/;" v typeref:struct:B +z testsuite/libgomp.c/reduction-11.c /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c/reduction-12.c /^struct B z[10];$/;" v typeref:struct:B +z testsuite/libgomp.c/reduction-13.c /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c/reduction-14.c /^struct B z[10];$/;" v typeref:struct:B +z testsuite/libgomp.c/reduction-7.c /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c/reduction-8.c /^struct B z[10];$/;" v typeref:struct:B +z testsuite/libgomp.c/reduction-9.c /^char z[10] = { 0 };$/;" v +z testsuite/libgomp.c/target-21.c /^struct S { int s; int u; struct T v; int x[10]; union U w; int y[10]; int z[10]; };$/;" m struct:S file: +z testsuite/libgomp.c/target-21.c /^volatile int z;$/;" v +z testsuite/libgomp.c/target-22.c /^volatile int z;$/;" v +z testsuite/libgomp.c/target-23.c /^volatile int z;$/;" v +z testsuite/libgomp.fortran/alloc-comp-3.f90 /^ type (dt), allocatable :: z(/;" v +z testsuite/libgomp.fortran/depend-3.f90 /^ integer, allocatable :: z(/;" v +z testsuite/libgomp.fortran/omp_parse3.f90 /^ integer :: x, y, z$/;" v +z testsuite/libgomp.hsa.c/formal-actual-args-1.c /^ int z;$/;" m struct:Cube file: +z testsuite/libgomp.oacc-c-c++-common/private-variables.c /^ int x, y, z;$/;" m struct:__anon25 file: +z testsuite/libgomp.oacc-fortran/declare-1.f90 /^ integer z$/;" v module:vars +z testsuite/libgomp.oacc-fortran/private-variables.f90 /^ integer x, y, z,/;" k type:vec3 +z1 testsuite/libgomp.c/atomic-10.c /^volatile unsigned char z1, z2, z3, z4, z5;$/;" v +z2 testsuite/libgomp.c/atomic-10.c /^volatile unsigned char z1, z2, z3, z4, z5;$/;" v +z3 testsuite/libgomp.c/atomic-10.c /^volatile unsigned char z1, z2, z3, z4, z5;$/;" v +z4 testsuite/libgomp.c/atomic-10.c /^volatile unsigned char z1, z2, z3, z4, z5;$/;" v +z5 testsuite/libgomp.c/atomic-10.c /^volatile unsigned char z1, z2, z3, z4, z5;$/;" v +zero config/nvptx/doacross.h /^static int zero;$/;" v +zero testsuite/libgomp.c++/reduction-10.C /^zero (T &x)$/;" f +zero testsuite/libgomp.c++/reduction-12.C /^zero (T &x)$/;" f +zero testsuite/libgomp.c++/reduction-6.C /^zero (T &x)$/;" f +zero testsuite/libgomp.c++/reduction-8.C /^zero (T &x)$/;" f +zero testsuite/libgomp.c/reduction-10.c /^zero (struct B *x)$/;" f +zero testsuite/libgomp.c/reduction-12.c /^zero (struct B *x)$/;" f +zero testsuite/libgomp.c/reduction-14.c /^zero (struct B *x)$/;" f +zero testsuite/libgomp.c/reduction-8.c /^zero (struct B *x)$/;" f +zero testsuite/libgomp.fortran/pr48894.f90 /^ integer, parameter :: zero /;" v +zero testsuite/libgomp.oacc-fortran/if-1.f90 /^ integer, parameter :: zero /;" v program:main +zero_init testsuite/libgomp.fortran/examples-4/task_dep-5.f90 /^ subroutine zero_init /;" s module:task_dep5_mod +zt testsuite/libgomp.c++/target-21.C /^int zt = 6;$/;" v +~A testsuite/libgomp.c++/ctor-12.C /^ virtual ~A ()$/;" f struct:A +~A testsuite/libgomp.c++/pr30703.C /^A::~A()$/;" f class:A +~A testsuite/libgomp.c++/pr48869.C /^ ~A () {}$/;" f struct:A +~A testsuite/libgomp.c++/pr81130.C /^A::~A ()$/;" f class:A +~A testsuite/libgomp.c++/reduction-10.C /^ ~A () {}$/;" f struct:A +~A testsuite/libgomp.c++/reduction-12.C /^ ~A () {}$/;" f struct:A +~A testsuite/libgomp.c++/reduction-6.C /^ ~A () {}$/;" f struct:A +~A testsuite/libgomp.c++/reduction-8.C /^ ~A () {}$/;" f struct:A +~A testsuite/libgomp.c++/task-3.C /^A::~A ()$/;" f class:A +~A testsuite/libgomp.c++/task-5.C /^A::~A ()$/;" f class:A +~B testsuite/libgomp.c++/ctor-1.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-10.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-11.C /^B::~B ()$/;" f class:B +~B testsuite/libgomp.c++/ctor-13.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-2.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-3.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-4.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-7.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/ctor-8.C /^B::~B()$/;" f class:B +~B testsuite/libgomp.c++/pr48869.C /^ ~B () {}$/;" f struct:B +~B testsuite/libgomp.c++/reduction-10.C /^ ~B () {}$/;" f struct:B +~B testsuite/libgomp.c++/reduction-12.C /^ ~B () {}$/;" f struct:B +~B testsuite/libgomp.c++/reduction-6.C /^ ~B () {}$/;" f struct:B +~B testsuite/libgomp.c++/reduction-8.C /^ ~B () {}$/;" f struct:B +~I testsuite/libgomp.c++/collapse-2.C /^template I::~I () { p = (T *) 0; }$/;" f class:I +~I testsuite/libgomp.c++/doacross-1.C /^template I::~I () {}$/;" f class:I +~I testsuite/libgomp.c++/for-1.C /^template I::~I () {}$/;" f class:I +~I testsuite/libgomp.c++/for-5.C /^template I::~I () { p = (T *) 0; }$/;" f class:I +~I testsuite/libgomp.c++/for-8.C /^template I::~I () {}$/;" f class:I +~I testsuite/libgomp.c++/member-5.C /^template I::~I () {}$/;" f class:I +~I testsuite/libgomp.c++/taskloop-6.C /^template I::~I () {}$/;" f class:I +~I testsuite/libgomp.c++/taskloop-9.C /^template I::~I () { p = (T *) 0; }$/;" f class:I +~M testsuite/libgomp.c++/reduction-10.C /^ ~M () {}$/;" f struct:M +~M testsuite/libgomp.c++/reduction-12.C /^ ~M () {}$/;" f struct:M +~M testsuite/libgomp.c++/reduction-6.C /^ ~M () {}$/;" f struct:M +~M testsuite/libgomp.c++/reduction-8.C /^ ~M () {}$/;" f struct:M +~R testsuite/libgomp.c++/member-1.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-2.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-3.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-4.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-5.C /^struct R { R () {}; ~R () {}; I r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-6.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~R testsuite/libgomp.c++/member-7.C /^struct R { R () {}; ~R () {}; int r; };$/;" f struct:R +~S testsuite/libgomp.c++/cancel-test.h /^ ~S ()$/;" f struct:S +~S testsuite/libgomp.c++/pr27337.C /^S::~S ()$/;" f class:S +~S testsuite/libgomp.c++/pr35185.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/pr81314.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/simd-4.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/simd-5.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/simd-6.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/simd-7.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/simd-8.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/target-21.C /^S::~S ()$/;" f class:S +~S testsuite/libgomp.c++/udr-1.C /^S::~S ()$/;" f class:S +~S testsuite/libgomp.c++/udr-2.C /^NS::S::~S ()$/;" f class:NS::S +~S testsuite/libgomp.c++/udr-3.C /^NS::S::~S ()$/;" f class:NS::S +~S testsuite/libgomp.c++/udr-4.C /^ ~S () {}$/;" f struct:S +~S testsuite/libgomp.c++/udr-7.C /^ ~S () {}$/;" f struct:S +~T testsuite/libgomp.c++/member-1.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-2.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-3.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-4.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-5.C /^struct T { T () {}; virtual ~T () {}; I t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-6.C /^struct T { T () {}; virtual ~T () {}; int t; };$/;" f struct:T +~T testsuite/libgomp.c++/member-7.C /^struct T { T () : t(d) {}; virtual ~T () {}; Q t; };$/;" f struct:T +~T testsuite/libgomp.c++/pr66702-2.C /^T::~T () {}$/;" f class:T +~U testsuite/libgomp.c++/member-5.C /^struct U { U () {}; virtual ~U () {}; Q t; };$/;" f struct:U +~U testsuite/libgomp.c++/simd-1.C /^U::~U ()$/;" f class:U +~V testsuite/libgomp.c++/simd-1.C /^ ~V ()$/;" f struct:V +~V testsuite/libgomp.c++/udr-3.C /^ ~V () {}$/;" f struct:V +~W testsuite/libgomp.c++/udr-3.C /^ ~W () {}$/;" f struct:W diff --git a/libgomp_taskgraph/ChangeLog b/libgomp_taskgraph/ChangeLog new file mode 100644 index 0000000000000000000000000000000000000000..c34a92840811e2db7bec56d686043ceee5556ccb --- /dev/null +++ b/libgomp_taskgraph/ChangeLog @@ -0,0 +1,8724 @@ +2019-11-14 Release Manager + + * GCC 7.5.0 released. + +2019-08-30 Jakub Jelinek + + Backported from mainline + 2019-05-24 Jakub Jelinek + + PR libgomp/90585 + * plugin/plugin-hsa.c (print_kernel_dispatch, run_kernel): Use PRIu64 + macro instead of "lu". + (release_kernel_dispatch): Likewise. Cast shadow->debug to uintptr_t + before casting to void *. + + 2019-06-11 Jakub Jelinek + + PR target/90811 + * testsuite/libgomp.c/pr90811.c: New test. + + 2019-01-28 Jakub Jelinek + + PR middle-end/89002 + * testsuite/libgomp.c/pr89002.c: New test. + +2018-12-06 Release Manager + + * GCC 7.4.0 released. + +2018-10-12 Jakub Jelinek + + Backported from mainline + 2018-07-17 Jakub Jelinek + + PR middle-end/86542 + * testsuite/libgomp.c++/pr86542.C: New test. + + PR middle-end/86539 + * testsuite/libgomp.c++/pr86539.C: New test. + + 2018-07-26 Jakub Jelinek + + PR middle-end/86660 + * testsuite/libgomp.c/pr86660.c: New test. + +2018-06-26 Jakub Jelinek + + PR c++/86291 + * testsuite/libgomp.c++/pr86291.C: New test. + +2018-06-22 Jakub Jelinek + + Backported from mainline + 2018-04-18 David Malcolm + + PR jit/85384 + * configure: Regenerate. + +2018-05-01 Tom de Vries + + backport from trunk: + 2018-04-16 Cesar Philippidis + Tom de Vries + + PR middle-end/84955 + * testsuite/libgomp.oacc-c-c++-common/pr84955.c: New test. + * testsuite/libgomp.oacc-fortran/pr84955.f90: New test. + +2018-03-03 Jakub Jelinek + + Backported from mainline + 2018-02-16 Jakub Jelinek + + PR fortran/84418 + * libgomp.fortran/pr84418-1.f90: New test. + * libgomp.fortran/pr84418-2.f90: New test. + + 2018-01-29 Christoph Spiel + Jakub Jelinek + + PR libgomp/84096 + * omp.h.in (omp_init_nest_lock_with_hint): Use omp_nest_lock_t + instead of omp_lock_t. + +2018-02-09 Martin Jambor + + Backport from mainline + 2018-02-08 Martin Jambor + + * testsuite/libgomp.hsa.c/staticvar.c: New test. + +2018-01-25 Release Manager + + * GCC 7.3.0 released. + +2017-12-15 Jakub Jelinek + + Backported from mainline + 2017-11-24 Jakub Jelinek + + PR fortran/81304 + * testsuite/libgomp.fortran/pr81304.f90: New test. + + 2017-11-23 Jakub Jelinek + + PR fortran/81841 + * libgomp.fortran/pr81841.f90: New test. + +2017-12-10 Tom de Vries + + backport from trunk: + PR c/81875 + 2017-09-16 Tom de Vries + + * testsuite/libgomp.c/pr81875.c: New test. + +2017-09-15 Jakub Jelinek + + Backported from mainline + 2017-09-14 Jakub Jelinek + + PR c++/81314 + * testsuite/libgomp.c++/pr81314.C: New test. + +2017-09-07 Jakub Jelinek + + Backported from mainline + 2017-08-09 Jakub Jelinek + + PR c/81687 + * testsuite/libgomp.c/pr81687-1.c: New test. + * testsuite/libgomp.c/pr81687-2.c: New test. + + 2017-07-27 Jakub Jelinek + + PR c/45784 + * testsuite/libgomp.c/pr45784.c: New test. + * testsuite/libgomp.c++/pr45784.C: New test. + +2017-08-14 Release Manager + + * GCC 7.2.0 released. + +2017-06-21 Jakub Jelinek + + PR c++/81130 + * testsuite/libgomp.c++/pr81130.C: New test. + +2017-06-02 Jakub Jelinek + + Backported from mainline + 2017-05-30 Jakub Jelinek + + PR libgomp/80822 + * config/linux/affinity.c (gomp_affinity_init_level_1): New function. + (gomp_affinity_init_level): Use it. Always analyze the core and thread + sibling lists, depending on level just pick up what CPUs to put + together into a place vs. whether add multiple ordered places. + +2017-05-26 Jakub Jelinek + + Backported from mainline + 2017-05-22 Jakub Jelinek + + PR middle-end/80809 + * testsuite/libgomp.c/pr80809-2.c: New test. + * testsuite/libgomp.c/pr80809-3.c: New test. + + PR middle-end/80809 + * testsuite/libgomp.c/pr80809-1.c: New test. + + PR middle-end/80853 + * testsuite/libgomp.c/pr80853.c: New test. + +2017-05-02 Release Manager + + * GCC 7.1.0 released. + +2017-04-27 Jakub Jelinek + + PR bootstrap/80531 + * configure.tgt (*-*-aix*): Add -frandom-seed=$@ to XCFLAGS to avoid + bootstrap compare failures. + +2017-04-20 Alexander Monakov + + Backport from mainline + 2017-04-20 Alexander Monakov + + * testsuite/libgomp.c/target-36.c: New testcase. + +2017-04-13 Jakub Jelinek + + * plugin/plugin-nvptx.c (cuda_lib_inited): Use signed char type + instead of char. + +2017-04-11 Jakub Jelinek + + PR libgomp/80394 + * testsuite/libgomp.c/pr80394.c: New test. + +2017-04-04 Jakub Jelinek + + PR libgomp/79876 + * config/posix/thread-stacksize.h: New file. + * config/darwin/thread-stacksize.h: New file. + * config/nvptx/thread-stacksize.h: New file. + * env.c: Include thread-stacksize.h. + (initialize_env): Initialize stacksize to GOMP_DEFAULT_STACKSIZE + instead of 0. Call pthread_attr_setstacksize even if + GOMP_DEFAULT_STACKSIZE is non-zero. + +2017-03-30 Jakub Jelinek + + * env.c (initialize_env): Initialize stacksize to 0. + +2017-03-22 Cesar Philippidis + + PR c++/80029 + * testsuite/libgomp.oacc-c-c++-common/declare-vla.c: New test. + +2017-03-08 Jakub Jelinek + + PR c/79940 + * testsuite/libgomp.c/pr79940.c: New test. + +2017-02-15 Rainer Orth + + * testsuite/libgomp.c/pr48591.c: Enable on all __float128 + targets. + Add __float128 options. + +2017-02-11 John David Anglin + + * testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c: Remove + hppa*-*-* dg-skip-if directive. + +2017-02-09 Jakub Jelinek + + * testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c: Move + dg-skip-if directive into a comment. + +2017-02-09 Nathan Sidwell + Chung-Lin Tang + + * testsuite/libgomp.oacc-c-c++-common/tile-1.c: New. + * testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c: Adjust and + add additional case. + * testsuite/libgomp.oacc-c-c++-common/vprop.c: XFAIL under + "openacc_nvidia_accel_selected". + * libgomp.oacc-fortran/nested-function-1.f90 (test2): + Add num_workers(8) clause. + +2017-02-08 John David Anglin + + * testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c: Skip on + hppa*-*-*. + * testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c: Don't + include complex.h on hppa*-*-hpux*. + * testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c: Likewise. + +2017-02-02 Thomas Schwinge + + * plugin/plugin-nvptx.c (nvptx_exec): Make it static. + + * libgomp-plugin.h (GOMP_OFFLOAD_openacc_parallel): Rename to + GOMP_OFFLOAD_openacc_exec. Adjust all users. + (GOMP_OFFLOAD_openacc_get_current_cuda_device): Rename to + GOMP_OFFLOAD_openacc_cuda_get_current_device. Adjust all users. + (GOMP_OFFLOAD_openacc_get_current_cuda_context): Rename to + GOMP_OFFLOAD_openacc_cuda_get_current_context. Adjust all users. + (GOMP_OFFLOAD_openacc_get_cuda_stream): Rename to + GOMP_OFFLOAD_openacc_cuda_get_stream. Adjust all users. + (GOMP_OFFLOAD_openacc_set_cuda_stream): Rename to + GOMP_OFFLOAD_openacc_cuda_set_stream. Adjust all users. + +2017-01-31 Thomas Schwinge + + * libgomp-plugin.h: #include . + (GOMP_OFFLOAD_get_name, GOMP_OFFLOAD_get_caps) + (GOMP_OFFLOAD_get_type, GOMP_OFFLOAD_get_num_devices) + (GOMP_OFFLOAD_init_device, GOMP_OFFLOAD_fini_device) + (GOMP_OFFLOAD_version, GOMP_OFFLOAD_load_image) + (GOMP_OFFLOAD_unload_image, GOMP_OFFLOAD_alloc, GOMP_OFFLOAD_free) + (GOMP_OFFLOAD_dev2host, GOMP_OFFLOAD_host2dev) + (GOMP_OFFLOAD_dev2dev, GOMP_OFFLOAD_can_run, GOMP_OFFLOAD_run) + (GOMP_OFFLOAD_async_run, GOMP_OFFLOAD_openacc_parallel) + (GOMP_OFFLOAD_openacc_register_async_cleanup) + (GOMP_OFFLOAD_openacc_async_test) + (GOMP_OFFLOAD_openacc_async_test_all) + (GOMP_OFFLOAD_openacc_async_wait) + (GOMP_OFFLOAD_openacc_async_wait_async) + (GOMP_OFFLOAD_openacc_async_wait_all) + (GOMP_OFFLOAD_openacc_async_wait_all_async) + (GOMP_OFFLOAD_openacc_async_set_async) + (GOMP_OFFLOAD_openacc_create_thread_data) + (GOMP_OFFLOAD_openacc_destroy_thread_data) + (GOMP_OFFLOAD_openacc_get_current_cuda_device) + (GOMP_OFFLOAD_openacc_get_current_cuda_context) + (GOMP_OFFLOAD_openacc_get_cuda_stream) + (GOMP_OFFLOAD_openacc_set_cuda_stream): New prototypes. + * libgomp.h (struct acc_dispatch_t, struct gomp_device_descr): Use + these. + * plugin/plugin-hsa.c (GOMP_OFFLOAD_load_image) + (GOMP_OFFLOAD_unload_image): Fix argument types. + +2017-01-26 Jakub Jelinek + + * testsuite/lib/libgomp.exp + (check_effective_target_hsa_offloading_selected_nocache): Fix up + check_compile invocation. Fix up removal of executable. Drop + bogus "2>&1" argument. + + * testsuite/libgomp.fortran/declare-simd-4.f90: Add cleanup-modules + directive. + +2017-01-24 Pekka Jääskeläinen + Martin Jambor + + * plugin/hsa.h: Moved to top level include. + * plugin/plugin-hsa.c: Chanfgd include of hsa.h accordingly. + +2017-01-21 Jakub Jelinek + + PR other/79046 + * testsuite/Makefile.am (gcc_version): Use @get_gcc_base_ver@ instead + of cat to get version from BASE-VER file. + * testsuite/Makefile.in: Regenerated. + +2017-01-19 Jakub Jelinek + + * plugin/cuda/cuda.h (CUdeviceptr): Typedef to unsigned long long even + for _WIN64. + +2017-01-17 Jakub Jelinek + + * plugin/hsa.h: Add GCC runtime library exception. + * plugin/hsa_ext_finalize.h: Likewise. + + * plugin/configfrag.ac: For --without-cuda-driver don't initialize + CUDA_DRIVER_INCLUDE nor CUDA_DRIVER_LIB. If both + CUDA_DRIVER_INCLUDE and CUDA_DRIVER_LIB are empty and linking small + cuda program fails, define PLUGIN_NVPTX_DYNAMIC to 1 and use + plugin/include/cuda as include dir and -ldl instead of -lcuda as + library to link ptx plugin against. + * plugin/plugin-nvptx.c: Include dlfcn.h if PLUGIN_NVPTX_DYNAMIC. + (CUDA_CALLS): Define. + (cuda_lib, cuda_lib_inited): New variables. + (init_cuda_lib): New function. + (CUDA_CALL_PREFIX): Define. + (CUDA_CALL_ERET, CUDA_CALL_ASSERT): Use CUDA_CALL_PREFIX. + (CUDA_CALL): Use FN instead of (FN). + (CUDA_CALL_NOCHECK): Define. + (cuda_error, fini_streams_for_device, select_stream_for_async, + nvptx_attach_host_thread_to_device, nvptx_open_device, link_ptx, + event_gc, nvptx_exec, nvptx_async_test, nvptx_async_test_all, + nvptx_wait_all, nvptx_set_clocktick, GOMP_OFFLOAD_unload_image, + nvptx_stacks_alloc, nvptx_stacks_free, GOMP_OFFLOAD_run): Use + CUDA_CALL_NOCHECK. + (nvptx_init): Call init_cuda_lib, if it fails, return false. Use + CUDA_CALL_NOCHECK. + (nvptx_get_num_devices): Call init_cuda_lib, if it fails, return 0. + Use CUDA_CALL_NOCHECK. + * plugin/cuda/cuda.h: New file. + * config.h.in: Regenerated. + * configure: Regenerated. + + PR other/79046 + * configure.ac: Add GCC_BASE_VER. + * Makefile.am (gcc_version): Use @get_gcc_base_ver@ instead of cat to + get version from BASE-VER file. + * testsuite/Makefile.in: Regenerated. + * configure: Regenerated. + * Makefile.in: Regenerated. + +2017-01-09 Francois-Xavier Coudert + + PR libgomp/60670 + * Makefile.am: Make fincludedir multilib-aware. + * Makefile.in: Regenerate. + +2017-01-01 Jakub Jelinek + + Update copyright years. + + * libgomp.texi: Bump @copying's copyright year. + +2016-12-02 Sebastian Huber + + * libgomp/config/rtems/pool.h (gomp_thread_pool_reservoir): Use + pthread_spinlock_t instead of gomp_mutex_t lock. + (gomp_get_thread_pool): Likewise. + (gomp_release_thread_pool): Likewise. + * libgomp/config/rtems/proc.c (allocate_thread_pool_reservoir): + Likewise. + +2016-12-02 Sebastian Huber + + * config/rtems/pool.h (gomp_get_thread_pool): Return proper + thread pool in case nthreads == 1. + +2016-11-30 Alexander Monakov + + * config/nvptx/env.c: Delete. + * icv.c: Move definitions of ICV variables back ... + * env.c: ...here. Do not compile environment-related functionality if + LIBGOMP_OFFLOADED_ONLY is set. + +2016-11-30 Alexander Monakov + + * configure.ac [nvptx*-*-*] (libgomp_offloaded_only): Set and use it... + (LIBGOMP_OFFLOADED_ONLY): ...here; new define. + * configure: Regenerate. + * config.h.in: Likewise. + +2016-11-30 Alexander Monakov + + * Makefile.in: Regenerate with automake-1.11.6. + * aclocal.m4: Likewise. + * configure: Likewise. + * testsuite/Makefile.in: Likewise. + +2016-11-28 Alexander Monakov + + * config/nvptx/critical.c: Delete to use generic implementation. + +2016-11-28 Jonas Hahnfeld + + * config/linux/affinity.c [!HAVE_PTHREAD_AFFINITY_NP]: Include + ../../affinity.c as fallback. + * config/nvptx/affinity.c: Delete to use fallback implementation. + +2016-11-23 Alexander Monakov + Jakub Jelinek + Dmitry Melnik + + * Makefile.am (libgomp_la_SOURCES): Add atomic.c, icv.c, icv-device.c. + * Makefile.in. Regenerate. + * configure.ac [nvptx*-*-*] (libgomp_use_pthreads): Set and use it... + (LIBGOMP_USE_PTHREADS): ...here; new define. + * configure: Regenerate. + * config.h.in: Likewise. + * config/posix/affinity.c: Move to... + * affinity.c: ...here (new file). Guard use of Pthreads-specific + interface by LIBGOMP_USE_PTHREADS. + * critical.c: Split out GOMP_atomic_{start,end} into... + * atomic.c: ...here (new file). + * env.c: Split out ICV definitions into... + * icv.c: ...here (new file) and... + * icv-device.c: ...here. New file. + * config/linux/lock.c (gomp_init_lock_30): Move to generic lock.c. + (gomp_destroy_lock_30): Ditto. + (gomp_set_lock_30): Ditto. + (gomp_unset_lock_30): Ditto. + (gomp_test_lock_30): Ditto. + (gomp_init_nest_lock_30): Ditto. + (gomp_destroy_nest_lock_30): Ditto. + (gomp_set_nest_lock_30): Ditto. + (gomp_unset_nest_lock_30): Ditto. + (gomp_test_nest_lock_30): Ditto. + * lock.c: New. + * config/nvptx/lock.c: New. + * config/nvptx/bar.c: New. + * config/nvptx/bar.h: New. + * config/nvptx/doacross.h: New. + * config/nvptx/error.c: New. + * config/nvptx/icv-device.c: New. + * config/nvptx/mutex.h: New. + * config/nvptx/pool.h: New. + * config/nvptx/proc.c: New. + * config/nvptx/ptrlock.h: New. + * config/nvptx/sem.h: New. + * config/nvptx/simple-bar.h: New. + * config/nvptx/target.c: New. + * config/nvptx/task.c: New. + * config/nvptx/team.c: New. + * config/nvptx/time.c: New. + * config/posix/simple-bar.h: New. + * libgomp.h: Guard pthread.h inclusion. Include simple-bar.h. + (gomp_num_teams_var): Declare. + (struct gomp_thread_pool): Change threads_dock member to + gomp_simple_barrier_t. + [__nvptx__] (gomp_thread): New implementation. + (gomp_thread_attr): Guard by LIBGOMP_USE_PTHREADS. + (gomp_thread_destructor): Ditto. + (gomp_init_thread_affinity): Ditto. + * team.c: Guard uses of Pthreads-specific interfaces by + LIBGOMP_USE_PTHREADS. Adjust all uses of threads_dock. + (gomp_free_thread) [__nvptx__]: Do not call 'free'. + * config/nvptx/alloc.c: Delete. + * config/nvptx/barrier.c: Ditto. + * config/nvptx/fortran.c: Ditto. + * config/nvptx/iter.c: Ditto. + * config/nvptx/iter_ull.c: Ditto. + * config/nvptx/loop.c: Ditto. + * config/nvptx/loop_ull.c: Ditto. + * config/nvptx/ordered.c: Ditto. + * config/nvptx/parallel.c: Ditto. + * config/nvptx/priority_queue.c: Ditto. + * config/nvptx/sections.c: Ditto. + * config/nvptx/single.c: Ditto. + * config/nvptx/splay-tree.c: Ditto. + * config/nvptx/work.c: Ditto. + * testsuite/libgomp.fortran/fortran.exp (lang_link_flags): Pass + -foffload=-lgfortran in addition to -lgfortran. + * testsuite/libgomp.oacc-fortran/fortran.exp (lang_link_flags): Ditto. + * plugin/plugin-nvptx.c: Include . + (struct targ_fn_descriptor): Add new fields. + (struct ptx_device): Ditto. Set them... + (nvptx_open_device): ...here. + (nvptx_adjust_launch_bounds): New. + (nvptx_host2dev): Allow NULL 'nvthd'. + (nvptx_dev2host): Ditto. + (GOMP_OFFLOAD_get_caps): Add GOMP_OFFLOAD_CAP_OPENMP_400. + (link_ptx): Adjust log sizes. + (nvptx_host2dev): Allow NULL 'nvthd'. + (nvptx_dev2host): Ditto. + (nvptx_set_clocktick): New. Use it... + (GOMP_OFFLOAD_load_image): ...here. Set new targ_fn_descriptor + fields. + (GOMP_OFFLOAD_dev2dev): New. + (nvptx_adjust_launch_bounds): New. + (nvptx_stacks_size): New. + (nvptx_stacks_alloc): New. + (nvptx_stacks_free): New. + (GOMP_OFFLOAD_run): New. + (GOMP_OFFLOAD_async_run): New (stub). + +2016-11-23 Martin Jambor + + * testsuite/libgomp.hsa.c/bits-insns.c: New test. + * testsuite/libgomp.hsa.c/tiling-1.c: Likewise. + * testsuite/libgomp.hsa.c/tiling-2.c: Likewise. + +2016-11-23 Martin Liska + Martin Jambor + + * plugin/hsa.h: New file. + * plugin/hsa_ext_finalize.h: New file. + * plugin/configfrag.ac: Remove hsa-kmt-lib test. Added checks for + header file unistd.h, and functions secure_getenv, __secure_getenv, + getuid, geteuid, getgid and getegid. + * plugin/Makefrag.am (libgomp_plugin_hsa_la_CPPFLAGS): Added + -D_GNU_SOURCE. + * plugin/plugin-hsa.c: Include config.h, inttypes.h and stdbool.h. + Handle various cases of secure_getenv presence, add an implementation + when we can test effective UID and GID. + (struct hsa_runtime_fn_info): New structure. + (hsa_runtime_fn_info hsa_fns): New variable. + (hsa_runtime_lib): Likewise. + (support_cpu_devices): Likewise. + (init_enviroment_variables): Load newly introduced ENV + variables. + (hsa_warn): Call hsa run-time functions via hsa_fns structure. + (hsa_fatal): Likewise. + (DLSYM_FN): New macro. + (init_hsa_runtime_functions): New function. + (suitable_hsa_agent_p): Call hsa run-time functions via hsa_fns + structure. Depending on environment, also allow CPU devices. + (init_hsa_context): Call hsa run-time functions via hsa_fns structure. + (get_kernarg_memory_region): Likewise. + (GOMP_OFFLOAD_init_device): Likewise. + (destroy_hsa_program): Likewise. + (init_basic_kernel_info): New function. + (GOMP_OFFLOAD_load_image): Use it. + (create_and_finalize_hsa_program): Call hsa run-time functions via + hsa_fns structure. + (create_single_kernel_dispatch): Likewise. + (release_kernel_dispatch): Likewise. + (init_single_kernel): Likewise. + (parse_target_attributes): Allow up multiple HSA grid dimensions. + (get_group_size): New function. + (run_kernel): Likewise. + (GOMP_OFFLOAD_run): Outline most functionality to run_kernel. + (GOMP_OFFLOAD_fini_device): Call hsa run-time functions via hsa_fns + structure. + * testsuite/lib/libgomp.exp: Remove hsa_kmt_lib support. + * testsuite/libgomp-test-support.exp.in: Likewise. + * Makefile.in: Regenerated. + * aclocal.m4: Likewise. + * config.h.in: Likewise. + * configure: Likewise. + * testsuite/Makefile.in: Likewise. + +2016-11-15 Martin Jambor + Alexander Monakov + + * testsuite/libgomp.fortran/examples-4/device-1.f90 (e_57_1): Add + mapping clauses to target constructs. + * testsuite/libgomp.fortran/examples-4/device-3.f90 (e_57_3): Ditto. + +2016-11-15 Matthias Klose + + * configure: Regenerate. + +2016-11-10 Jakub Jelinek + + * omp_lib.f90.in (openmp_version): Change to 201511 from 201307. + * omp_lib.h.in (openmp_version): Likewise. + * testsuite/libgomp.fortran/openmp_version-1.f: Expect 201511 instead + of 201307. + * testsuite/libgomp.fortran/openmp_version-2.f90: Likewise. + + * testsuite/libgomp.fortran/examples-4/declare_target-1.f90 + (fib_wrapper): Add map(from: x) clause. + * testsuite/libgomp.fortran/examples-4/declare_target-2.f90 + (e_53_2): Likewise. + * testsuite/libgomp.fortran/examples-4/declare_target-4.f90 + (accum): Add map(tmp) clause. + * testsuite/libgomp.fortran/examples-4/declare_target-5.f90 + (accum): Add map(tofrom: tmp) clause. + * testsuite/libgomp.fortran/examples-4/target_data-3.f90 + (gramSchmidt): Likewise. + * testsuite/libgomp.fortran/examples-4/teams-2.f90 (dotprod): Add + map(tofrom: sum) clause. + * testsuite/libgomp.fortran/nestedfn5.f90 (foo): Add twice + map (alloc: a, l) clause. Add defaultmap(tofrom: scalar) clause. + * testsuite/libgomp.fortran/pr66199-2.f90: Adjust for linear clause + only allowed on the loop iterator. + * testsuite/libgomp.fortran/target4.f90 (foo): Add map(t) clause. + * testsuite/libgomp.fortran/taskloop2.f90: New test. + * testsuite/libgomp.fortran/taskloop4.f90: New test. + * testsuite/libgomp.fortran/doacross1.f90: New test. + * testsuite/libgomp.fortran/doacross3.f90: New test. + * testsuite/libgomp.fortran/taskloop1.f90: New test. + * testsuite/libgomp.fortran/taskloop3.f90: New test. + * testsuite/libgomp.fortran/doacross2.f90: New test. + * testsuite/libgomp.c/doacross-1.c (main): Add missing + #pragma omp atomic read. + * testsuite/libgomp.c/doacross-2.c (main): Likewise. + * testsuite/libgomp.c/doacross-3.c (main): Likewise. + +2016-11-02 Cesar Philippidis + Nathan Sidwell + + * plugin/plugin-nvptx.c (nvptx_exec): Interrogate board attributes + to determine default geometry. + * testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c: Set gang + dimension. + +2016-11-01 Jakub Jelinek + + * hashtab.h: Use standard GPLv3 with runtime exception + boilerplate. + +2016-10-27 Aldy Hernandez + + * oacc-init.c (goacc_new_thread): Use sizeof of the appropriate + size when allocating new thread. + +2016-09-14 Marek Polacek + + * testsuite/libgomp.c++/atomic-3.C: Use -Wno-deprecated. + +2016-08-19 Jakub Jelinek + + PR fortran/71014 + * testsuite/libgomp.fortran/pr71014.f90: New test. + +2016-08-18 Chung-Lin Tang + + PR middle-end/70895 + * testsuite/libgomp.oacc-fortran/reduction-7.f90: Add explicit + firstprivate clauses. + * testsuite/libgomp.oacc-fortran/reduction-6.f90: Remove explicit + copy clauses. + * testsuite/libgomp.oacc-c-c++-common/reduction-7.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-cplx-flt.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-flt.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/collapse-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-wv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/collapse-4.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-v-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-cplx-dbl.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-g-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-gwv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-w-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-dbl.c: Likewise. + +2016-08-14 Chung-Lin Tang + + PR fortran/70598 + * testsuite/libgomp.oacc-fortran/host_data-1.f90: New test. + +2016-08-08 Jakub Jelinek + + PR c++/58706 + * testsuite/libgomp.c++/pr58706.C: New test. + +2016-08-04 Thomas Schwinge + + * testsuite/libgomp.oacc-c++/routine-1-auto.C: New file. + * testsuite/libgomp.oacc-c++/routine-1-template-auto.C: Likewise. + * testsuite/libgomp.oacc-c++/routine-1-template-trailing-return-type.C: + Likewise. + * testsuite/libgomp.oacc-c++/routine-1-template.C: Likewise. + * testsuite/libgomp.oacc-c++/routine-1-trailing-return-type.C: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-1.c: Adjust. + + * testsuite/libgomp.oacc-c-c++-common/crash-1.c: Make it a "link" + test, and don't hardcode -O0. + +2016-08-03 Nathan Sidwell + + * testsuite/libgomp.oacc-c-c++-common/crash-1.c: New. + +2016-07-15 Cesar Philippidis + + * testsuite/libgomp.oacc-c-c++-common/zero_length_subarrays.c: New + test. + +2016-07-03 H.J. Lu + + PR middle-end/71734 + * testsuite/libgomp.fortran/pr71734-1.f90: New test. + * testsuite/libgomp.fortran/pr71734-2.f90: Likewise. + +2016-07-01 Jakub Jelinek + + PR fortran/71717 + * testsuite/libgomp.fortran/associate3.f90: New test. + +2016-06-17 Jakub Jelinek + + * testsuite/libgomp.c++/target-21.C: New test. + +2016-06-16 Jakub Jelinek + + * testsuite/libgomp.c++/target-20.C: New test. + +2016-06-10 Thomas Schwinge + Cesar Philippidis + + PR middle-end/71373 + * libgomp.oacc-c/nested-function-1.c: New file. + * libgomp.oacc-c/nested-function-2.c: Likewise. + * libgomp.oacc-fortran/nested-function-1.f90: Likewise. + * libgomp.oacc-fortran/nested-function-2.f90: Likewise. + * libgomp.oacc-fortran/nested-function-3.f90: Likewise. + +2016-06-10 Thomas Schwinge + + PR c/71381 + * testsuite/libgomp.oacc-c-c++-common/cache-1.c: #include + "../../../gcc/testsuite/c-c++-common/goacc/cache-1.c". + * testsuite/libgomp.oacc-fortran/cache-1.f95: New file. + +2016-06-03 Chung-Lin Tang + + * testsuite/libgomp.oacc-fortran/reduction-8.f90: New testcase. + * testsuite/libgomp.oacc-c-c++-common/reduction-8.c: New testcase. + +2016-06-01 Cesar Philippidis + + PR c/70688 + * testsuite/libgomp.oacc-c-c++-common/pr70688.c: New file. + +2016-05-26 Jakub Jelinek + + * testsuite/libgomp.c/doacross-1.c (main): Use schedule(static) + instead of invalid schedule(static, 0). + * testsuite/libgomp.c/doacross-2.c (main): Likewise. + +2016-05-26 Chung-Lin Tang + + * oacc-plugin.h (GOMP_PLUGIN_async_unmap_vars): Add int parameter. + * oacc-plugin.c (GOMP_PLUGIN_async_unmap_vars): Add 'int async' + parameter, use to set async stream around call to gomp_unmap_vars, + call gomp_unmap_vars() with 'do_copyfrom' set to true. + * plugin/plugin-nvptx.c (struct ptx_event): Add 'int val' field. + (event_gc): Adjust event handling loop, collect PTX_EVT_ASYNC_CLEANUP + events and call GOMP_PLUGIN_async_unmap_vars() for each of them. + (event_add): Add int parameter, initialize 'val' field when + adding new ptx_event struct. + (nvptx_evec): Adjust event_add() call arguments. + (nvptx_host2dev): Likewise. + (nvptx_dev2host): Likewise. + (nvptx_wait_async): Likewise. + (nvptx_wait_all_async): Likewise. + (GOMP_OFFLOAD_openacc_register_async_cleanup): Add async parameter, + pass to event_add() call. + * oacc-host.c (host_openacc_register_async_cleanup): Add 'int async' + parameter. + * oacc-mem.c (gomp_acc_remove_pointer): Adjust async case to + call openacc.register_async_cleanup_func() hook. + * oacc-parallel.c (GOACC_parallel_keyed): Likewise. + * target.c (gomp_copy_from_async): Delete function. + (gomp_map_vars): Remove async_refcount. + (gomp_unmap_vars): Likewise. + (gomp_load_image_to_device): Likewise. + (omp_target_associate_ptr): Likewise. + * libgomp.h (struct splay_tree_key_s): Remove async_refcount. + (acc_dispatch_t.register_async_cleanup_func): Add int parameter. + (gomp_copy_from_async): Remove. + +2016-05-26 Chung-Lin Tang + + * target.c (gomp_device_copy): New function. + (gomp_copy_host2dev): Likewise. + (gomp_copy_dev2host): Likewise. + (gomp_free_device_memory): Likewise. + (gomp_map_vars_existing): Adjust to call gomp_copy_host2dev. + (gomp_map_pointer): Likewise. + (gomp_map_vars): Adjust to call gomp_copy_host2dev, handle + NULL value from alloc_func plugin hook. + (gomp_unmap_tgt): Adjust to call gomp_free_device_memory. + (gomp_copy_from_async): Adjust to call gomp_copy_dev2host. + (gomp_unmap_vars): Likewise. + (gomp_update): Adjust to call gomp_copy_dev2host and + gomp_copy_host2dev functions. + (gomp_unload_image_from_device): Handle false value from + unload_image_func plugin hook. + (gomp_init_device): Handle false value from init_device_func + plugin hook. + (gomp_exit_data): Adjust to call gomp_copy_dev2host. + (omp_target_free): Adjust to call gomp_free_device_memory. + (omp_target_memcpy): Handle return values from host2dev_func, + dev2host_func, and dev2dev_func plugin hooks. + (omp_target_memcpy_rect_worker): Likewise. + (gomp_target_fini): Handle false value from fini_device_func + plugin hook. + * libgomp.h (struct gomp_device_descr): Adjust return type of + init_device_func, fini_device_func, unload_image_func, free_func, + dev2host_func,host2dev_func, and dev2dev_func plugin hooks to 'bool'. + * oacc-init.c (acc_shutdown_1): Handle false value from + fini_device_func plugin hook. + * oacc-host.c (host_init_device): Change return type to bool. + (host_fini_device): Likewise. + (host_unload_image): Likewise. + (host_free): Likewise. + (host_dev2host): Likewise. + (host_host2dev): Likewise. + * oacc-mem.c (acc_free): Handle plugin hook fatal error case. + (acc_memcpy_to_device): Likewise. + (acc_memcpy_from_device): Likewise. + (delete_copyout): Add libfnname parameter, handle free_func + hook fatal error case. + (acc_delete): Adjust delete_copyout call. + (acc_copyout): Likewise. + (update_dev_host): Move gomp_mutex_unlock to after + host2dev/dev2host hook calls. + + * plugin/plugin-hsa.c (hsa_warn): Adjust 'hsa_error' local variable + to 'hsa_error_msg', for clarity. + (hsa_fatal): Likewise. + (hsa_error): New function. + (init_hsa_context): Change return type to bool, adjust to return + false on error. + (GOMP_OFFLOAD_get_num_devices): Adjust to handle init_hsa_context + return value. + (GOMP_OFFLOAD_init_device): Change return type to bool, adjust to + return false on error. + (get_agent_info): Adjust to return NULL on error. + (destroy_hsa_program): Change return type to bool, adjust to + return false on error. + (GOMP_OFFLOAD_load_image): Adjust to return -1 on error. + (destroy_module): Change return type to bool, adjust to + return false on error. + (GOMP_OFFLOAD_unload_image): Likewise. + (GOMP_OFFLOAD_fini_device): Likewise. + (GOMP_OFFLOAD_alloc): Change to return NULL when called. + (GOMP_OFFLOAD_free): Change to return false when called. + (GOMP_OFFLOAD_dev2host): Likewise. + (GOMP_OFFLOAD_host2dev): Likewise. + (GOMP_OFFLOAD_dev2dev): Likewise. + + * plugin/plugin-nvptx.c (CUDA_CALL_ERET): New convenience macro. + (CUDA_CALL): Likewise. + (CUDA_CALL_ASSERT): Likewise. + (map_init): Change return type to bool, use CUDA_CALL* macros. + (map_fini): Likewise. + (init_streams_for_device): Change return type to bool, adjust + call to map_init. + (fini_streams_for_device): Change return type to bool, adjust + call to map_fini. + (select_stream_for_async): Release stream_lock before calls to + GOMP_PLUGIN_fatal, adjust call to map_init. + (nvptx_init): Use CUDA_CALL* macros. + (nvptx_attach_host_thread_to_device): Change return type to bool, + use CUDA_CALL* macros. + (nvptx_open_device): Use CUDA_CALL* macros. + (nvptx_close_device): Change return type to bool, use CUDA_CALL* + macros. + (nvptx_get_num_devices): Use CUDA_CALL* macros. + (link_ptx): Change return type to bool, use CUDA_CALL* macros. + (nvptx_exec): Use CUDA_CALL* macros. + (nvptx_alloc): Use CUDA_CALL* macros. + (nvptx_free): Change return type to bool, use CUDA_CALL* macros. + (nvptx_host2dev): Likewise. + (nvptx_dev2host): Likewise. + (nvptx_wait): Use CUDA_CALL* macros. + (nvptx_wait_async): Likewise. + (nvptx_wait_all): Likewise. + (nvptx_wait_all_async): Likewise. + (nvptx_set_cuda_stream): Adjust order of stream_lock acquire, + use CUDA_CALL* macros, adjust call to map_fini. + (GOMP_OFFLOAD_init_device): Change return type to bool, + adjust code accordingly. + (GOMP_OFFLOAD_fini_device): Likewise. + (GOMP_OFFLOAD_load_image): Adjust calls to + nvptx_attach_host_thread_to_device/link_ptx to handle errors, + use CUDA_CALL* macros. + (GOMP_OFFLOAD_unload_image): Change return type to bool, adjust + return code. + (GOMP_OFFLOAD_alloc): Adjust calls to code to handle error return. + (GOMP_OFFLOAD_free): Change return type to bool, adjust calls to + handle error return. + (GOMP_OFFLOAD_dev2host): Likewise. + (GOMP_OFFLOAD_host2dev): Likewise. + (GOMP_OFFLOAD_openacc_register_async_cleanup): Use CUDA_CALL* macros. + (GOMP_OFFLOAD_openacc_create_thread_data): Likewise. + +2016-05-24 Cesar Philippidis + + * oacc-mem.c (acc_malloc): Update handling of shared-memory targets. + (acc_free): Likewise. + (acc_memcpy_to_device): Likewise. + (acc_memcpy_from_device): Likewise. + (acc_deviceptr): Likewise. + (acc_hostptr): Likewise. + (acc_is_present): Likewise. + (acc_map_data): Likewise. + (acc_unmap_data): Likewise. + (present_create_copy): Likewise. + (delete_copyout): Likewise. + (update_dev_host): Likewise. + * testsuite/libgomp.oacc-c-c++-common/asyncwait-1.c: Remove xfail. + * testsuite/libgomp.oacc-c-c++-common/data-2-lib.c: New test. + * testsuite/libgomp.oacc-c-c++-common/data-2.c: Adjust test. + * testsuite/libgomp.oacc-c-c++-common/data-3.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/enter_exit-lib.c: New test. + * testsuite/libgomp.oacc-c-c++-common/lib-13.c: Adjust test so that + it only runs on nvptx targets. + * testsuite/libgomp.oacc-c-c++-common/lib-14.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-15.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-16.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-17.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-18.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-20.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-21.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-22.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-23.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-24.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-25.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-28.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-29.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-30.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-34.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-42.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-43.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-44.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-47.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-48.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-52.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-53.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/lib-54.c: Likewise. + +2016-05-23 Martin Jambor + + * testsuite/libgomp.hsa.c/switch-sbr-2.c: New test. + +2016-05-17 Chung-Lin Tang + + * oacc-init.c (acc_init): Remove !cached_base_dev condition on call + to gomp_init_targets_once. + (acc_set_device_type): Remove !cached_base_dev condition on call to + gomp_init_targets_once, move call to before acc_device_lock acquire, + to avoid deadlock. + (acc_get_device_num): Remove !cached_base_dev condition on call to + gomp_init_targets_once. + (acc_set_device_num): Likewise. + +2016-05-16 Martin Jambor + + * testsuite/libgomp.hsa.c/complex-align-2.c: New test. + +2016-05-02 Nathan Sidwell + + * testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c: Adjust + expected partitioning. + +2016-04-29 Cesar Philippidis + + PR middle-end/70626 + * testsuite/libgomp.oacc-c++/template-reduction.C: Adjust test. + * testsuite/libgomp.oacc-c-c++-common/combined-reduction.c: New test. + * testsuite/libgomp.oacc-fortran/combined-reduction.f90: New test. + +2016-04-21 Alexander Monakov + + * plugin/plugin-nvptx.c (map_fini): Make cuMemFreeHost error + non-fatal. + +2016-04-19 Jakub Jelinek + + PR middle-end/70680 + * testsuite/libgomp.c/pr70680-1.c: New test. + * testsuite/libgomp.c/pr70680-2.c: New test. + +2016-04-14 Cesar Philippidis + + * testsuite/libgomp.oacc-fortran/non-scalar-data.f90: Don't + pass parameter variables to subroutines. + +2016-04-14 Cesar Philippidis + + PR middle-end/70643 + * testsuite/libgomp.oacc-fortran/pr70643.f90: New test. + +2016-04-13 Cesar Philippidis + + PR testsuite/68242 + * testsuite/libgomp.oacc-c-c++-common/reduction-1.c: Adjust test. + * testsuite/libgomp.oacc-c-c++-common/reduction-2.c: Likewise. + +2016-04-12 Thomas Schwinge + + * libgomp_g.h: Rename GOACC_parallel_keyd prototype to + GOACC_parallel_keyed, restore GOACC_parallel prototype, new + GOACC_declare prototype. + + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gang-np-1.c: + Merge this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gv-np-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gw-np-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-2.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-3.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-4.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-vector-p-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-vector-p-2.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-worker-p-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-1.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-2.c: + ... this file, and... + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-3.c: + ... this file into... + * testsuite/libgomp.oacc-c-c++-common/reduction-7.c: ... this + file. + + * testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-2.c: + Make failure observable. + +2016-04-12 Jakub Jelinek + + * libgomp.h (struct gomp_target_task): Remove firstprivate_copies + field. + * target.c (gomp_target_fallback_firstprivate, + gomp_target_unshare_firstprivate): Removed. + (GOMP_target_ext): Copy firstprivate vars into gomp_allocaed memory + before waiting for dependencies. + (gomp_target_task_fn): Don't copy firstprivate vars here. + * task.c (GOMP_PLUGIN_target_task_completion): Don't free + firstprivate_copies here. + (gomp_create_target_task): Don't initialize firstprivate_copies field. + * testsuite/libgomp.c/target-25.c (main): Use map (to:) instead of + explicit/implicit firstprivate. + +2016-04-08 Cesar Philippidis + + PR lto/70289 + PR ipa/70348 + PR tree-optimization/70373 + PR middle-end/70533 + PR middle-end/70534 + PR middle-end/70535 + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gang-np-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gw-np-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-2.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-3.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-gwv-np-4.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-vector-p-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-vector-p-2.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-worker-p-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-1.c: New test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-2.c: New test. + * testsuite/libgomp.oacc-c-c++-common/loop-reduction-wv-p-3.c: New test. + * testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-1.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-2.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-3.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/par-loop-comb-reduction-4.c: New + test. + * testsuite/libgomp.oacc-c-c++-common/par-reduction-1.c: Add test + coverage. + * testsuite/libgomp.oacc-c-c++-common/par-reduction-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/parallel-dims.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/parallel-reduction.c: New test. + * testsuite/libgomp.oacc-c-c++-common/pr70289.c: New test. + * testsuite/libgomp.oacc-c-c++-common/pr70373.c: New test. + * testsuite/libgomp.oacc-c-c++-common/reduction-1.c: Add test + coverage. + * testsuite/libgomp.oacc-c-c++-common/reduction-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-3.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-4.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-5.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-6.c: New test. + * testsuite/libgomp.oacc-c-c++-common/reduction.h: New test. + * testsuite/libgomp.oacc-fortran/parallel-reduction.f90: New test. + * testsuite/libgomp.oacc-fortran/pr70289.f90: New test. + * testsuite/libgomp.oacc-fortran/reduction-1.f90: Add test coverage. + * testsuite/libgomp.oacc-fortran/reduction-2.f90: Likewise. + * testsuite/libgomp.oacc-fortran/reduction-3.f90: Likewise. + * testsuite/libgomp.oacc-fortran/reduction-4.f90: Likewise. + * testsuite/libgomp.oacc-fortran/reduction-5.f90: Likewise. + * testsuite/libgomp.oacc-fortran/reduction-6.f90: Likewise. + * testsuite/libgomp.oacc-fortran/reduction-7.f90: New test. + +2016-03-30 Thomas Schwinge + James Norris + Nathan Sidwell + Julian Brown + Cesar Philippidis + Chung-Lin Tang + Tom de Vries + + * testsuite/libgomp.oacc-c-c++-common/clauses-1.c: Update. + * testsuite/libgomp.oacc-c-c++-common/deviceptr-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/if-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/vector-loop.c: Likewise. + * testsuite/libgomp.oacc-fortran/asyncwait-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/asyncwait-2.f90: Likewise. + * testsuite/libgomp.oacc-fortran/asyncwait-3.f90: Likewise. + * testsuite/libgomp.oacc-fortran/declare-1.f90: Likewise. + * testsuite/libgomp.oacc-c-c++-common/asyncwait-1.c: Likewise. + XFAIL. + * testsuite/libgomp.oacc-c-c++-common/firstprivate-1.c: Update. + Incorporate... + * testsuite/libgomp.oacc-c-c++-common/firstprivate-2.c: ... this + file. + * testsuite/libgomp.oacc-c++/template-reduction.C: New file. + * testsuite/libgomp.oacc-c-c++-common/gang-static-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/gang-static-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-clauses.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/private-variables.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/reduction-7.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-4.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-wv-2.c: Likewise. + * testsuite/libgomp.oacc-fortran/clauses-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/default-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/firstprivate-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/gang-static-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/if-1.f90: Likewise. + * testsuite/libgomp.oacc-fortran/implicit-firstprivate-ref.f90: + Likewise. + * testsuite/libgomp.oacc-fortran/pr68813.f90: Likewise. + * testsuite/libgomp.oacc-fortran/private-variables.f90: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-1.c: Merge this + file... + * testsuite/libgomp.oacc-c-c++-common/parallel-1.c: ..., and this + file into... + * testsuite/libgomp.oacc-c-c++-common/data-clauses.h: ... this new + file. Update. + * testsuite/libgomp.oacc-c-c++-common/data-clauses-kernels.c: New + file. + * testsuite/libgomp.oacc-c-c++-common/data-clauses-parallel.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-2.c: Rename to... + * testsuite/libgomp.oacc-c-c++-common/data-clauses-kernels-ipa-pta.c: + ... this new file. Update. + * testsuite/libgomp.oacc-c-c++-common/parallel-2.c: Rename to... + * testsuite/libgomp.oacc-c-c++-common/data-clauses-parallel-ipa-pta.c: + ... this new file. Update. + * testsuite/libgomp.oacc-c-c++-common/mode-transitions.c: New + file. Incorporate... + * testsuite/libgomp.oacc-c-c++-common/worker-single-1a.c: ... this + file, and... + * testsuite/libgomp.oacc-c-c++-common/worker-single-4.c: ... this + file, and... + * testsuite/libgomp.oacc-c-c++-common/worker-single-6.c: ... this + file. + * testsuite/libgomp.oacc-c-c++-common/update-1-2.c: Remove file. + +2016-03-29 Thomas Schwinge + + * testsuite/libgomp.oacc-c++/c++.exp [!lang_test_file_found]: Call + set-torture-options. + +2016-03-24 Thomas Schwinge + + * testsuite/libgomp.oacc-c++/c++.exp: Set up torture testing, use + gcc-dg-runtest. + * testsuite/libgomp.oacc-c/c.exp: Likewise. + * testsuite/libgomp.oacc-c-c++-common/acc-on-device-2.c: Specify + -fno-builtin-acc_on_device instead of -O0. + * testsuite/libgomp.oacc-c-c++-common/acc-on-device.c: Skip for + -O0. + * testsuite/libgomp.oacc-c-c++-common/loop-auto-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-g-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-g-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-gwv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-g-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-gwv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-v-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-v-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-w-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-red-w-2.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-v-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-w-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/loop-wv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-g-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-gwv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-v-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-w-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/routine-wv-1.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-2.c: + Don't specify -O2. + * testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta-3.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-alias-ipa-pta.c: + Likewise. + +2016-03-24 Martin Liska + + * plugin/plugin-hsa.c (packet_store_release): New function + that is taken from the HSA runtime manual. + (GOMP_OFFLOAD_run): Use the function. + +2016-03-23 Jakub Jelinek + + PR c++/70376 + * testsuite/libgomp.c++/pr70376.C: New test. + +2016-03-23 Tom de Vries + + * testsuite/libgomp.oacc-fortran/reduction-2.f90: Add missing + initialization of lresult and lvresult. + * testsuite/libgomp.oacc-fortran/reduction-3.f90: Same. + +2016-03-23 James Norris + Daichi Fukuoka + + PR libgomp/69414 + * oacc-mem.c (delete_copyout, update_dev_host): Fix device address. + * testsuite/libgomp.oacc-c-c++-common/update-1.c: Additional tests. + * testsuite/libgomp.oacc-c-c++-common/update-1-2.c: Likewise. + * testsuite/libgomp.oacc-fortran/update-1.f90: New file. + +2016-03-23 Martin Liska + + PR hsa/70337 + * plugin/plugin-hsa.c (GOMP_OFFLOAD_run): Copy shadow + argument just in case a dispatched kernel uses that argument. + +2016-03-16 Thomas Schwinge + + * testsuite/libgomp.oacc-fortran/kernels-loop-2.f95: Adjust to + -ftree-parallelize-loops/-fopenacc changes. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95: + Likewise. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95: + Likewise. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95: + Likewise. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95: + Likewise. + * testsuite/libgomp.oacc-fortran/kernels-loop-data.f95: Likewise. + * testsuite/libgomp.oacc-fortran/kernels-loop.f95: Likewise. + +2016-03-13 Thomas Schwinge + + * testsuite/lib/libgomp.exp (libgomp_init): Potentially append to + always_ld_library_path the path to libgcc_s. + +2016-03-10 Cesar Philippidis + + PR testsuite/70009 + * testsuite/libgomp.oacc-c-c++-common/vprop.c: Make test data signed. + +2016-03-09 Tom de Vries + + * testsuite/libgomp.oacc-fortran/kernels-loop-2.f95: New test. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-2.f95: Same. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit-2.f95: + Same. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-enter-exit.f95: Same. + * testsuite/libgomp.oacc-fortran/kernels-loop-data-update.f95: Same. + * testsuite/libgomp.oacc-fortran/kernels-loop-data.f95: Same. + * testsuite/libgomp.oacc-fortran/kernels-loop.f95: Same. + +2016-03-07 Martin Jambor + + * testsuite/lib/libgomp.exp + (check_effective_target_hsa_offloading_selected_nocache): New. + (check_effective_target_hsa_offloading_selected): Likewise. + * testsuite/libgomp.hsa.c/c.exp: Likewise. + * testsuite/libgomp.hsa.c/alloca-1.c: Likewise. + * testsuite/libgomp.hsa.c/bitfield-1.c: Likewise. + * testsuite/libgomp.hsa.c/builtins-1.c: Likewise. + * testsuite/libgomp.hsa.c/complex-1.c: Likewise. + * testsuite/libgomp.hsa.c/formal-actual-args-1.c: Likewise. + * testsuite/libgomp.hsa.c/function-call-1.c: Likewise. + * testsuite/libgomp.hsa.c/get-level-1.c: Likewise. + * testsuite/libgomp.hsa.c/gridify-1.c: Likewise. + * testsuite/libgomp.hsa.c/gridify-2.c: Likewise. + * testsuite/libgomp.hsa.c/gridify-3.c: Likewise. + * testsuite/libgomp.hsa.c/gridify-4.c: Likewise. + * testsuite/libgomp.hsa.c/memory-operations-1.c: Likewise. + * testsuite/libgomp.hsa.c/pr69568.c: Likewise. + * testsuite/libgomp.hsa.c/rotate-1.c: Likewise. + * testsuite/libgomp.hsa.c/switch-1.c: Likewise. + * testsuite/libgomp.hsa.c/switch-branch-1.c: Likewise. + +2016-03-07 Martin Jambor + + * testsuite/libgomp.c/examples-4/async_target-2.c: Only run on + non-shared memory accelerators. + * testsuite/libgomp.c/examples-4/device-1.c: Likewise. + * testsuite/libgomp.c/examples-4/target-5.c: Likewise. + * testsuite/libgomp.c/examples-4/target_data-6.c: Likewise. + * testsuite/libgomp.c/examples-4/target_data-7.c: Likewise. + * testsuite/libgomp.fortran/examples-4/async_target-2.f90: Likewise. + * testsuite/libgomp.fortran/examples-4/device-1.f90: Likewise. + * testsuite/libgomp.fortran/examples-4/target-5.f90: Likewise. + * testsuite/libgomp.fortran/examples-4/target_data-6.f90: Likewise. + * testsuite/libgomp.fortran/examples-4/target_data-7.f90: Likewise. + +2016-03-07 Martin Jambor + + * testsuite/lib/libgomp.exp (libgomp_init): Append -Wno-hsa to + ALWAYS_CFLAGS. + +2016-03-02 Jakub Jelinek + + PR libgomp/69555 + * testsuite/libgomp.c++/pr69555-1.C: New test. + * testsuite/libgomp.c++/pr69555-2.C: New test. + +2016-02-26 Keith McDaniel + Martin Jambor + + * testsuite/lib/libgomp.exp + (check_effective_target_offload_device_shared_as): New proc. + * testsuite/libgomp.c++/declare_target-1.C: New test. + +2016-02-25 Ilya Verbin + + PR driver/68463 + * testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c: Remove. + +2016-02-23 Thomas Schwinge + + * oacc-parallel.c (GOACC_parallel_keyed): Initialize dims. + * plugin/plugin-nvptx.c (nvptx_exec): Provide default values for + dims. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-2.c: Adjust to + -ftree-parallelize-loops/-fopenacc changes. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-3.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-2.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-3.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-4.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-5.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq-6.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-and-seq.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-collapse.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-g.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-mod-not-zero.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-n.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop-nest.c: + Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-loop.c: Likewise. + * testsuite/libgomp.oacc-c-c++-common/kernels-reduction.c: + Likewise. + +2016-02-22 Cesar Philippidis + + * testsuite/libgomp.oacc-c-c++-common/vprop.c: New test. + +2016-02-19 Jakub Jelinek + + PR driver/69805 + * testsuite/libgomp.c/pr69805.c: New test. + +2016-02-16 Tom de Vries + + PR lto/67709 + * testsuite/libgomp.fortran/declare-simd-4.f90: New test. + +2016-02-09 Tom de Vries + + PR tree-optimization/69599 + * testsuite/libgomp.c/omp-nested-3.c: New test. + * testsuite/libgomp.c/pr46032-2.c: New test. + * testsuite/libgomp.oacc-c-c++-common/kernels-2.c: New test. + * testsuite/libgomp.oacc-c-c++-common/parallel-2.c: New test. + +2016-02-09 Tom de Vries + + PR lto/69707 + * testsuite/libgomp.oacc-c-c++-common/parallel-dims-2.c: New test. + +2016-02-02 Alexander Monakov + + * testsuite/libgomp.c/target-31.c: Fix testcase. + +2016-02-02 Alexander Monakov + + * testsuite/libgomp.c/examples-4/teams-3.c: Add missing reduction + clause. + * testsuite/libgomp.c/examples-4/teams-4.c: Likewise. + * testsuite/libgomp.fortran/examples-4/teams-3.f90: Add missing + reduction and map clauses. + * testsuite/libgomp.fortran/examples-4/teams-4.f90: Likewise. + +2016-02-02 James Norris + + * testsuite/libgomp.oacc-c-c++-common/declare-4.c: Fix clause. + +2016-02-02 Thomas Schwinge + + * libgomp.map (GOACC_2.0): Remove GOACC_host_data. + * oacc-parallel.c (GOACC_host_data): Remove function definition. + + * testsuite/lib/libgomp.exp: Skip hsa offloading for OpenACC test + cases. + + * plugin/configfrag.ac (HSA_KMT_LIB, HSA_KMT_LDFLAGS): New + variables. + * testsuite/libgomp-test-support.exp.in (hsa_runtime_lib) + (hsa_kmt_lib): Set variables. + * testsuite/lib/libgomp.exp (libgomp_init): Use them to amend + always_ld_library_path. + * Makefile.in: Regenerate. + * configure: Likewise. + * testsuite/Makefile.in: Likewise. + + * plugin/configfrag.ac (offload_additional_options) + (offload_additional_lib_paths): Don't amend for hsa offloading. + * configure: Regenerate. + + * plugin/configfrag.ac: Don't configure for offloading target if + we don't build the corresponding plugin. + * configure: Regenerate. + +2016-02-01 Nathan Sidwell + + * testsuite/libgomp.oacc-c-c++-common/loop-dim-default.c: New. + * testsuite/libgomp.oacc-fortran/routine-7.f90: Serialize loop. + +2016-01-26 Tom de Vries + + PR tree-optimization/69110 + * testsuite/libgomp.c/pr69110.c: New test. + +2016-01-25 Richard Biener + + PR lto/69393 + * testsuite/libgomp.c++/pr69393.C: New testcase. + +2016-01-22 Ilya Verbin + + * target.c (gomp_get_target_fn_addr): Allow host fallback if target + function wasn't mapped to the device with non-shared memory. + +2016-01-20 Ilya Verbin + + * task.c (gomp_create_target_task): Set firstprivate_copies to NULL. + +2016-01-19 Martin Jambor + Martin Liska + + * plugin/Makefrag.am: Add HSA plugin requirements. + * plugin/configfrag.ac (HSA_RUNTIME_INCLUDE): New variable. + (HSA_RUNTIME_LIB): Likewise. + (HSA_RUNTIME_CPPFLAGS): Likewise. + (HSA_RUNTIME_INCLUDE): New substitution. + (HSA_RUNTIME_LIB): Likewise. + (HSA_RUNTIME_LDFLAGS): Likewise. + (hsa-runtime): New configure option. + (hsa-runtime-include): Likewise. + (hsa-runtime-lib): Likewise. + (PLUGIN_HSA): New