1 /* Copyright (C) 2005-2014 Free Software Foundation, Inc.
2 Contributed by Richard Henderson <rth@redhat.com>.
3
4 This file is part of the GNU OpenMP Library (libgomp).
5
6 Libgomp is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13 FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 more details.
15
16 Under Section 7 of GPL version 3, you are granted additional
17 permissions described in the GCC Runtime Library Exception, version
18 3.1, as published by the Free Software Foundation.
19
20 You should have received a copy of the GNU General Public License and
21 a copy of the GCC Runtime Library Exception along with this program;
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 <http://www.gnu.org/licenses/>. */
24
25 /* This file contains data types and function declarations that are not
26 part of the official OpenMP user interface. There are declarations
27 in here that are part of the GNU OpenMP ABI, in that the compiler is
28 required to know about them and use them.
29
30 The convention is that the all caps prefix "GOMP" is used group items
31 that are part of the external ABI, and the lower case prefix "gomp"
32 is used group items that are completely private to the library. */
33
34 #ifndef LIBGOMP_H
35 #define LIBGOMP_H 1
36
37 #include "config.h"
38 #include "gstdint.h"
39
40 #include <pthread.h>
41 #include <stdbool.h>
42 #include <stdlib.h>
43
44 #ifdef HAVE_ATTRIBUTE_VISIBILITY
45 # pragma GCC visibility push(hidden)
46 #endif
47
48 /* If we were a C++ library, we'd get this from <std/atomic>. */
49 enum memmodel
50 {
51 MEMMODEL_RELAXED = 0,
52 MEMMODEL_CONSUME = 1,
53 MEMMODEL_ACQUIRE = 2,
54 MEMMODEL_RELEASE = 3,
55 MEMMODEL_ACQ_REL = 4,
56 MEMMODEL_SEQ_CST = 5
57 };
58
59 #include "sem.h"
60 #include "mutex.h"
61 #include "bar.h"
62 #include "ptrlock.h"
63
64
65 /* This structure contains the data to control one work-sharing construct,
66 either a LOOP (FOR/DO) or a SECTIONS. */
67
68 enum gomp_schedule_type
69 {
70 GFS_RUNTIME,
71 GFS_STATIC,
72 GFS_DYNAMIC,
73 GFS_GUIDED,
74 GFS_AUTO
75 };
76
77 struct gomp_work_share
78 {
79 /* This member records the SCHEDULE clause to be used for this construct.
80 The user specification of "runtime" will already have been resolved.
81 If this is a SECTIONS construct, this value will always be DYNAMIC. */
82 enum gomp_schedule_type sched;
83
84 int mode;
85
86 union {
87 struct {
88 /* This is the chunk_size argument to the SCHEDULE clause. */
89 long chunk_size;
90
91 /* This is the iteration end point. If this is a SECTIONS construct,
92 this is the number of contained sections. */
93 long end;
94
95 /* This is the iteration step. If this is a SECTIONS construct, this
96 is always 1. */
97 long incr;
98 };
99
100 struct {
101 /* The same as above, but for the unsigned long long loop variants. */
102 unsigned long long chunk_size_ull;
103 unsigned long long end_ull;
104 unsigned long long incr_ull;
105 };
106 };
107
108 /* This is a circular queue that details which threads will be allowed
109 into the ordered region and in which order. When a thread allocates
110 iterations on which it is going to work, it also registers itself at
111 the end of the array. When a thread reaches the ordered region, it
112 checks to see if it is the one at the head of the queue. If not, it
113 blocks on its RELEASE semaphore. */
114 unsigned *ordered_team_ids;
115
116 /* This is the number of threads that have registered themselves in
117 the circular queue ordered_team_ids. */
118 unsigned ordered_num_used;
119
120 /* This is the team_id of the currently acknowledged owner of the ordered
121 section, or -1u if the ordered section has not been acknowledged by
122 any thread. This is distinguished from the thread that is *allowed*
123 to take the section next. */
124 unsigned ordered_owner;
125
126 /* This is the index into the circular queue ordered_team_ids of the
127 current thread that's allowed into the ordered reason. */
128 unsigned ordered_cur;
129
130 /* This is a chain of allocated gomp_work_share blocks, valid only
131 in the first gomp_work_share struct in the block. */
132 struct gomp_work_share *next_alloc;
133
134 /* The above fields are written once during workshare initialization,
135 or related to ordered worksharing. Make sure the following fields
136 are in a different cache line. */
137
138 /* This lock protects the update of the following members. */
139 gomp_mutex_t lock __attribute__((aligned (64)));
140
141 /* This is the count of the number of threads that have exited the work
142 share construct. If the construct was marked nowait, they have moved on
143 to other work; otherwise they're blocked on a barrier. The last member
144 of the team to exit the work share construct must deallocate it. */
145 unsigned threads_completed;
146
147 union {
148 /* This is the next iteration value to be allocated. In the case of
149 GFS_STATIC loops, this the iteration start point and never changes. */
150 long next;
151
152 /* The same, but with unsigned long long type. */
153 unsigned long long next_ull;
154
155 /* This is the returned data structure for SINGLE COPYPRIVATE. */
156 void *copyprivate;
157 };
158
159 union {
160 /* Link to gomp_work_share struct for next work sharing construct
161 encountered after this one. */
162 gomp_ptrlock_t next_ws;
163
164 /* gomp_work_share structs are chained in the free work share cache
165 through this. */
166 struct gomp_work_share *next_free;
167 };
168
169 /* If only few threads are in the team, ordered_team_ids can point
170 to this array which fills the padding at the end of this struct. */
171 unsigned inline_ordered_team_ids[0];
172 };
173
174 /* This structure contains all of the thread-local data associated with
175 a thread team. This is the data that must be saved when a thread
176 encounters a nested PARALLEL construct. */
177
178 struct gomp_team_state
179 {
180 /* This is the team of which the thread is currently a member. */
181 struct gomp_team *team;
182
183 /* This is the work share construct which this thread is currently
184 processing. Recall that with NOWAIT, not all threads may be
185 processing the same construct. */
186 struct gomp_work_share *work_share;
187
188 /* This is the previous work share construct or NULL if there wasn't any.
189 When all threads are done with the current work sharing construct,
190 the previous one can be freed. The current one can't, as its
191 next_ws field is used. */
192 struct gomp_work_share *last_work_share;
193
194 /* This is the ID of this thread within the team. This value is
195 guaranteed to be between 0 and N-1, where N is the number of
196 threads in the team. */
197 unsigned team_id;
198
199 /* Nesting level. */
200 unsigned level;
201
202 /* Active nesting level. Only active parallel regions are counted. */
203 unsigned active_level;
204
205 /* Place-partition-var, offset and length into gomp_places_list array. */
206 unsigned place_partition_off;
207 unsigned place_partition_len;
208
209 #ifdef HAVE_SYNC_BUILTINS
210 /* Number of single stmts encountered. */
211 unsigned long single_count;
212 #endif
213
214 /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the
215 trip number through the loop. So first time a particular loop
216 is encountered this number is 0, the second time through the loop
217 is 1, etc. This is unused when the compiler knows in advance that
218 the loop is statically scheduled. */
219 unsigned long static_trip;
220 };
221
222 struct target_mem_desc;
223
224 /* These are the OpenMP 4.0 Internal Control Variables described in
225 section 2.3.1. Those described as having one copy per task are
226 stored within the structure; those described as having one copy
227 for the whole program are (naturally) global variables. */
228
229 struct gomp_task_icv
230 {
231 unsigned long nthreads_var;
232 enum gomp_schedule_type run_sched_var;
233 int run_sched_modifier;
234 int default_device_var;
235 unsigned int thread_limit_var;
236 bool dyn_var;
237 bool nest_var;
238 char bind_var;
239 /* Internal ICV. */
240 struct target_mem_desc *target_data;
241 };
242
243 extern struct gomp_task_icv gomp_global_icv;
244 #ifndef HAVE_SYNC_BUILTINS
245 extern gomp_mutex_t gomp_managed_threads_lock;
246 #endif
247 extern unsigned long gomp_max_active_levels_var;
248 extern bool gomp_cancel_var;
249 extern unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var;
250 extern unsigned long gomp_available_cpus, gomp_managed_threads;
251 extern unsigned long *gomp_nthreads_var_list, gomp_nthreads_var_list_len;
252 extern char *gomp_bind_var_list;
253 extern unsigned long gomp_bind_var_list_len;
254 extern void **gomp_places_list;
255 extern unsigned long gomp_places_list_len;
256
257 enum gomp_task_kind
258 {
259 GOMP_TASK_IMPLICIT,
260 GOMP_TASK_IFFALSE,
261 GOMP_TASK_WAITING,
262 GOMP_TASK_TIED
263 };
264
265 struct gomp_task;
266 struct gomp_taskgroup;
267 struct htab;
268
269 struct gomp_task_depend_entry
270 {
271 void *addr;
272 struct gomp_task_depend_entry *next;
273 struct gomp_task_depend_entry *prev;
274 struct gomp_task *task;
275 bool is_in;
276 bool redundant;
277 bool redundant_out;
278 };
279
280 struct gomp_dependers_vec
281 {
282 size_t n_elem;
283 size_t allocated;
284 struct gomp_task *elem[];
285 };
286
287 /* Used when in GOMP_taskwait or in gomp_task_maybe_wait_for_dependencies. */
288
289 struct gomp_taskwait
290 {
291 bool in_taskwait;
292 bool in_depend_wait;
293 size_t n_depend;
294 struct gomp_task *last_parent_depends_on;
295 gomp_sem_t taskwait_sem;
296 };
297
298 /* This structure describes a "task" to be run by a thread. */
299
300 struct gomp_task
301 {
302 struct gomp_task *parent;
303 struct gomp_task *children;
304 struct gomp_task *next_child;
305 struct gomp_task *prev_child;
306 struct gomp_task *next_queue;
307 struct gomp_task *prev_queue;
308 struct gomp_task *next_taskgroup;
309 struct gomp_task *prev_taskgroup;
310 struct gomp_taskgroup *taskgroup;
311 struct gomp_dependers_vec *dependers;
312 struct htab *depend_hash;
313 struct gomp_taskwait *taskwait;
314 size_t depend_count;
315 size_t num_dependees;
316 struct gomp_task_icv icv;
317 void (*fn) (void *);
318 void *fn_data;
319 enum gomp_task_kind kind;
320 bool in_tied_task;
321 bool final_task;
322 bool copy_ctors_done;
323 bool parent_depends_on;
324 struct gomp_task_depend_entry depend[];
325 };
326
327 struct gomp_taskgroup
328 {
329 struct gomp_taskgroup *prev;
330 struct gomp_task *children;
331 bool in_taskgroup_wait;
332 bool cancelled;
333 gomp_sem_t taskgroup_sem;
334 size_t num_children;
335 };
336
337 /* This structure describes a "team" of threads. These are the threads
338 that are spawned by a PARALLEL constructs, as well as the work sharing
339 constructs that the team encounters. */
340
341 struct gomp_team
342 {
343 /* This is the number of threads in the current team. */
344 unsigned nthreads;
345
346 /* This is number of gomp_work_share structs that have been allocated
347 as a block last time. */
348 unsigned work_share_chunk;
349
350 /* This is the saved team state that applied to a master thread before
351 the current thread was created. */
352 struct gomp_team_state prev_ts;
353
354 /* This semaphore should be used by the master thread instead of its
355 "native" semaphore in the thread structure. Required for nested
356 parallels, as the master is a member of two teams. */
357 gomp_sem_t master_release;
358
359 /* This points to an array with pointers to the release semaphore
360 of the threads in the team. */
361 gomp_sem_t **ordered_release;
362
363 /* List of work shares on which gomp_fini_work_share hasn't been
364 called yet. If the team hasn't been cancelled, this should be
365 equal to each thr->ts.work_share, but otherwise it can be a possibly
366 long list of workshares. */
367 struct gomp_work_share *work_shares_to_free;
368
369 /* List of gomp_work_share structs chained through next_free fields.
370 This is populated and taken off only by the first thread in the
371 team encountering a new work sharing construct, in a critical
372 section. */
373 struct gomp_work_share *work_share_list_alloc;
374
375 /* List of gomp_work_share structs freed by free_work_share. New
376 entries are atomically added to the start of the list, and
377 alloc_work_share can safely only move all but the first entry
378 to work_share_list alloc, as free_work_share can happen concurrently
379 with alloc_work_share. */
380 struct gomp_work_share *work_share_list_free;
381
382 #ifdef HAVE_SYNC_BUILTINS
383 /* Number of simple single regions encountered by threads in this
384 team. */
385 unsigned long single_count;
386 #else
387 /* Mutex protecting addition of workshares to work_share_list_free. */
388 gomp_mutex_t work_share_list_free_lock;
389 #endif
390
391 /* This barrier is used for most synchronization of the team. */
392 gomp_barrier_t barrier;
393
394 /* Initial work shares, to avoid allocating any gomp_work_share
395 structs in the common case. */
396 struct gomp_work_share work_shares[8];
397
398 gomp_mutex_t task_lock;
399 struct gomp_task *task_queue;
400 /* Number of all GOMP_TASK_{WAITING,TIED} tasks in the team. */
401 unsigned int task_count;
402 /* Number of GOMP_TASK_WAITING tasks currently waiting to be scheduled. */
403 unsigned int task_queued_count;
404 /* Number of GOMP_TASK_{WAITING,TIED} tasks currently running
405 directly in gomp_barrier_handle_tasks; tasks spawned
406 from e.g. GOMP_taskwait or GOMP_taskgroup_end don't count, even when
407 that is called from a task run from gomp_barrier_handle_tasks.
408 task_running_count should be always <= team->nthreads,
409 and if current task isn't in_tied_task, then it will be
410 even < team->nthreads. */
411 unsigned int task_running_count;
412 int work_share_cancelled;
413 int team_cancelled;
414
415 /* This array contains structures for implicit tasks. */
416 struct gomp_task implicit_task[];
417 };
418
419 /* This structure contains all data that is private to libgomp and is
420 allocated per thread. */
421
422 struct gomp_thread
423 {
424 /* This is the function that the thread should run upon launch. */
425 void (*fn) (void *data);
426 void *data;
427
428 /* This is the current team state for this thread. The ts.team member
429 is NULL only if the thread is idle. */
430 struct gomp_team_state ts;
431
432 /* This is the task that the thread is currently executing. */
433 struct gomp_task *task;
434
435 /* This semaphore is used for ordered loops. */
436 gomp_sem_t release;
437
438 /* Place this thread is bound to plus one, or zero if not bound
439 to any place. */
440 unsigned int place;
441
442 /* User pthread thread pool */
443 struct gomp_thread_pool *thread_pool;
444 };
445
446
447 struct gomp_thread_pool
448 {
449 /* This array manages threads spawned from the top level, which will
450 return to the idle loop once the current PARALLEL construct ends. */
451 struct gomp_thread **threads;
452 unsigned threads_size;
453 unsigned threads_used;
454 struct gomp_team *last_team;
455 /* Number of threads running in this contention group. */
456 unsigned long threads_busy;
457
458 /* This barrier holds and releases threads waiting in threads. */
459 gomp_barrier_t threads_dock;
460 };
461
462 enum gomp_cancel_kind
463 {
464 GOMP_CANCEL_PARALLEL = 1,
465 GOMP_CANCEL_LOOP = 2,
466 GOMP_CANCEL_FOR = GOMP_CANCEL_LOOP,
467 GOMP_CANCEL_DO = GOMP_CANCEL_LOOP,
468 GOMP_CANCEL_SECTIONS = 4,
469 GOMP_CANCEL_TASKGROUP = 8
470 };
471
472 /* ... and here is that TLS data. */
473
474 #ifdef HAVE_TLS
475 extern __thread struct gomp_thread gomp_tls_data;
gomp_thread(void)476 static inline struct gomp_thread *gomp_thread (void)
477 {
478 return &gomp_tls_data;
479 }
480 #else
481 extern pthread_key_t gomp_tls_key;
gomp_thread(void)482 static inline struct gomp_thread *gomp_thread (void)
483 {
484 return pthread_getspecific (gomp_tls_key);
485 }
486 #endif
487
488 extern struct gomp_task_icv *gomp_new_icv (void);
489
490 /* Here's how to access the current copy of the ICVs. */
491
gomp_icv(bool write)492 static inline struct gomp_task_icv *gomp_icv (bool write)
493 {
494 struct gomp_task *task = gomp_thread ()->task;
495 if (task)
496 return &task->icv;
497 else if (write)
498 return gomp_new_icv ();
499 else
500 return &gomp_global_icv;
501 }
502
503 /* The attributes to be used during thread creation. */
504 extern pthread_attr_t gomp_thread_attr;
505
506 /* Function prototypes. */
507
508 /* affinity.c */
509
510 extern void gomp_init_affinity (void);
511 extern void gomp_init_thread_affinity (pthread_attr_t *, unsigned int);
512 extern void **gomp_affinity_alloc (unsigned long, bool);
513 extern void gomp_affinity_init_place (void *);
514 extern bool gomp_affinity_add_cpus (void *, unsigned long, unsigned long,
515 long, bool);
516 extern bool gomp_affinity_remove_cpu (void *, unsigned long);
517 extern bool gomp_affinity_copy_place (void *, void *, long);
518 extern bool gomp_affinity_same_place (void *, void *);
519 extern bool gomp_affinity_finalize_place_list (bool);
520 extern bool gomp_affinity_init_level (int, unsigned long, bool);
521 extern void gomp_affinity_print_place (void *);
522
523 /* alloc.c */
524
525 extern void *gomp_malloc (size_t) __attribute__((malloc));
526 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc));
527 extern void *gomp_realloc (void *, size_t);
528
529 /* Avoid conflicting prototypes of alloca() in system headers by using
530 GCC's builtin alloca(). */
531 #define gomp_alloca(x) __builtin_alloca(x)
532
533 /* error.c */
534
535 extern void gomp_error (const char *, ...)
536 __attribute__((format (printf, 1, 2)));
537 extern void gomp_fatal (const char *, ...)
538 __attribute__((noreturn, format (printf, 1, 2)));
539
540 /* iter.c */
541
542 extern int gomp_iter_static_next (long *, long *);
543 extern bool gomp_iter_dynamic_next_locked (long *, long *);
544 extern bool gomp_iter_guided_next_locked (long *, long *);
545
546 #ifdef HAVE_SYNC_BUILTINS
547 extern bool gomp_iter_dynamic_next (long *, long *);
548 extern bool gomp_iter_guided_next (long *, long *);
549 #endif
550
551 /* iter_ull.c */
552
553 extern int gomp_iter_ull_static_next (unsigned long long *,
554 unsigned long long *);
555 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *,
556 unsigned long long *);
557 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *,
558 unsigned long long *);
559
560 #if defined HAVE_SYNC_BUILTINS && defined __LP64__
561 extern bool gomp_iter_ull_dynamic_next (unsigned long long *,
562 unsigned long long *);
563 extern bool gomp_iter_ull_guided_next (unsigned long long *,
564 unsigned long long *);
565 #endif
566
567 /* ordered.c */
568
569 extern void gomp_ordered_first (void);
570 extern void gomp_ordered_last (void);
571 extern void gomp_ordered_next (void);
572 extern void gomp_ordered_static_init (void);
573 extern void gomp_ordered_static_next (void);
574 extern void gomp_ordered_sync (void);
575
576 /* parallel.c */
577
578 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
579
580 /* proc.c (in config/) */
581
582 extern void gomp_init_num_threads (void);
583 extern unsigned gomp_dynamic_max_threads (void);
584
585 /* task.c */
586
587 extern void gomp_init_task (struct gomp_task *, struct gomp_task *,
588 struct gomp_task_icv *);
589 extern void gomp_end_task (void);
590 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t);
591
592 static void inline
gomp_finish_task(struct gomp_task * task)593 gomp_finish_task (struct gomp_task *task)
594 {
595 if (__builtin_expect (task->depend_hash != NULL, 0))
596 free (task->depend_hash);
597 }
598
599 /* team.c */
600
601 extern struct gomp_team *gomp_new_team (unsigned);
602 extern void gomp_team_start (void (*) (void *), void *, unsigned,
603 unsigned, struct gomp_team *);
604 extern void gomp_team_end (void);
605 extern void gomp_free_thread (void *);
606
607 /* target.c */
608
609 extern int gomp_get_num_devices (void);
610
611 /* work.c */
612
613 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned);
614 extern void gomp_fini_work_share (struct gomp_work_share *);
615 extern bool gomp_work_share_start (bool);
616 extern void gomp_work_share_end (void);
617 extern bool gomp_work_share_end_cancel (void);
618 extern void gomp_work_share_end_nowait (void);
619
620 static inline void
gomp_work_share_init_done(void)621 gomp_work_share_init_done (void)
622 {
623 struct gomp_thread *thr = gomp_thread ();
624 if (__builtin_expect (thr->ts.last_work_share != NULL, 1))
625 gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share);
626 }
627
628 #ifdef HAVE_ATTRIBUTE_VISIBILITY
629 # pragma GCC visibility pop
630 #endif
631
632 /* Now that we're back to default visibility, include the globals. */
633 #include "libgomp_g.h"
634
635 /* Include omp.h by parts. */
636 #include "omp-lock.h"
637 #define _LIBGOMP_OMP_LOCK_DEFINED 1
638 #include "omp.h.in"
639
640 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \
641 || !defined (HAVE_ATTRIBUTE_ALIAS) \
642 || !defined (HAVE_AS_SYMVER_DIRECTIVE) \
643 || !defined (PIC) \
644 || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
645 # undef LIBGOMP_GNU_SYMBOL_VERSIONING
646 #endif
647
648 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
649 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
650 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
651 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
652 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
653 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
654 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
655 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
656 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
657 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
658 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
659
660 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
661 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
662 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
663 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
664 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
665 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
666 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
667 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
668 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
669 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
670
671 # define strong_alias(fn, al) \
672 extern __typeof (fn) al __attribute__ ((alias (#fn)));
673 # define omp_lock_symver(fn) \
674 __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \
675 __asm (".symver g" #fn "_25, " #fn "@OMP_1.0");
676 #else
677 # define gomp_init_lock_30 omp_init_lock
678 # define gomp_destroy_lock_30 omp_destroy_lock
679 # define gomp_set_lock_30 omp_set_lock
680 # define gomp_unset_lock_30 omp_unset_lock
681 # define gomp_test_lock_30 omp_test_lock
682 # define gomp_init_nest_lock_30 omp_init_nest_lock
683 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock
684 # define gomp_set_nest_lock_30 omp_set_nest_lock
685 # define gomp_unset_nest_lock_30 omp_unset_nest_lock
686 # define gomp_test_nest_lock_30 omp_test_nest_lock
687 #endif
688
689 #ifdef HAVE_ATTRIBUTE_VISIBILITY
690 # define attribute_hidden __attribute__ ((visibility ("hidden")))
691 #else
692 # define attribute_hidden
693 #endif
694
695 #ifdef HAVE_ATTRIBUTE_ALIAS
696 # define ialias_ulp ialias_str1(__USER_LABEL_PREFIX__)
697 # define ialias_str1(x) ialias_str2(x)
698 # define ialias_str2(x) #x
699 # define ialias(fn) \
700 extern __typeof (fn) gomp_ialias_##fn \
701 __attribute__ ((alias (#fn))) attribute_hidden;
702 # define ialias_redirect(fn) \
703 extern __typeof (fn) fn __asm__ (ialias_ulp "gomp_ialias_" #fn) attribute_hidden;
704 # define ialias_call(fn) gomp_ialias_ ## fn
705 #else
706 # define ialias(fn)
707 # define ialias_redirect(fn)
708 # define ialias_call(fn) fn
709 #endif
710
711 #endif /* LIBGOMP_H */
712