Reverting merge from trunk
[official-gcc.git] / libgomp / libgomp.h
blobbdc0486ad12c4ac7221e78be4cd29e7954990e6b
1 /* Copyright (C) 2005-2013 Free Software Foundation, Inc.
2 Contributed by Richard Henderson <rth@redhat.com>.
4 This file is part of the GNU OpenMP Library (libgomp).
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.
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.
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.
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/>. */
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.
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. */
34 #ifndef LIBGOMP_H
35 #define LIBGOMP_H 1
37 #include "config.h"
38 #include "gstdint.h"
40 #include <pthread.h>
41 #include <stdbool.h>
42 #include <stdlib.h>
44 #ifdef HAVE_ATTRIBUTE_VISIBILITY
45 # pragma GCC visibility push(hidden)
46 #endif
48 /* If we were a C++ library, we'd get this from <std/atomic>. */
49 enum memmodel
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
59 #include "sem.h"
60 #include "mutex.h"
61 #include "bar.h"
62 #include "ptrlock.h"
65 /* This structure contains the data to control one work-sharing construct,
66 either a LOOP (FOR/DO) or a SECTIONS. */
68 enum gomp_schedule_type
70 GFS_RUNTIME,
71 GFS_STATIC,
72 GFS_DYNAMIC,
73 GFS_GUIDED,
74 GFS_AUTO
77 struct gomp_work_share
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;
84 int mode;
86 union {
87 struct {
88 /* This is the chunk_size argument to the SCHEDULE clause. */
89 long chunk_size;
91 /* This is the iteration end point. If this is a SECTIONS construct,
92 this is the number of contained sections. */
93 long end;
95 /* This is the iteration step. If this is a SECTIONS construct, this
96 is always 1. */
97 long incr;
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;
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;
116 /* This is the number of threads that have registered themselves in
117 the circular queue ordered_team_ids. */
118 unsigned ordered_num_used;
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;
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;
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;
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. */
138 /* This lock protects the update of the following members. */
139 gomp_mutex_t lock __attribute__((aligned (64)));
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;
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;
152 /* The same, but with unsigned long long type. */
153 unsigned long long next_ull;
155 /* This is the returned data structure for SINGLE COPYPRIVATE. */
156 void *copyprivate;
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;
164 /* gomp_work_share structs are chained in the free work share cache
165 through this. */
166 struct gomp_work_share *next_free;
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];
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. */
178 struct gomp_team_state
180 /* This is the team of which the thread is currently a member. */
181 struct gomp_team *team;
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;
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;
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;
199 /* Nesting level. */
200 unsigned level;
202 /* Active nesting level. Only active parallel regions are counted. */
203 unsigned active_level;
205 /* Place-partition-var, offset and length into gomp_places_list array. */
206 unsigned place_partition_off;
207 unsigned place_partition_len;
209 #ifdef HAVE_SYNC_BUILTINS
210 /* Number of single stmts encountered. */
211 unsigned long single_count;
212 #endif
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;
222 struct target_mem_desc;
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. */
229 struct gomp_task_icv
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;
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;
257 enum gomp_task_kind
259 GOMP_TASK_IMPLICIT,
260 GOMP_TASK_IFFALSE,
261 GOMP_TASK_WAITING,
262 GOMP_TASK_TIED
265 struct gomp_task;
266 struct gomp_taskgroup;
267 struct htab;
269 struct gomp_task_depend_entry
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;
279 struct gomp_dependers_vec
281 size_t n_elem;
282 size_t allocated;
283 struct gomp_task *elem[];
286 /* This structure describes a "task" to be run by a thread. */
288 struct gomp_task
290 struct gomp_task *parent;
291 struct gomp_task *children;
292 struct gomp_task *next_child;
293 struct gomp_task *prev_child;
294 struct gomp_task *next_queue;
295 struct gomp_task *prev_queue;
296 struct gomp_task *next_taskgroup;
297 struct gomp_task *prev_taskgroup;
298 struct gomp_taskgroup *taskgroup;
299 struct gomp_dependers_vec *dependers;
300 struct htab *depend_hash;
301 size_t depend_count;
302 size_t num_dependees;
303 struct gomp_task_icv icv;
304 void (*fn) (void *);
305 void *fn_data;
306 enum gomp_task_kind kind;
307 bool in_taskwait;
308 bool in_tied_task;
309 bool final_task;
310 bool copy_ctors_done;
311 gomp_sem_t taskwait_sem;
312 struct gomp_task_depend_entry depend[];
315 struct gomp_taskgroup
317 struct gomp_taskgroup *prev;
318 struct gomp_task *children;
319 bool in_taskgroup_wait;
320 bool cancelled;
321 gomp_sem_t taskgroup_sem;
322 size_t num_children;
325 /* This structure describes a "team" of threads. These are the threads
326 that are spawned by a PARALLEL constructs, as well as the work sharing
327 constructs that the team encounters. */
329 struct gomp_team
331 /* This is the number of threads in the current team. */
332 unsigned nthreads;
334 /* This is number of gomp_work_share structs that have been allocated
335 as a block last time. */
336 unsigned work_share_chunk;
338 /* This is the saved team state that applied to a master thread before
339 the current thread was created. */
340 struct gomp_team_state prev_ts;
342 /* This semaphore should be used by the master thread instead of its
343 "native" semaphore in the thread structure. Required for nested
344 parallels, as the master is a member of two teams. */
345 gomp_sem_t master_release;
347 /* This points to an array with pointers to the release semaphore
348 of the threads in the team. */
349 gomp_sem_t **ordered_release;
351 /* List of work shares on which gomp_fini_work_share hasn't been
352 called yet. If the team hasn't been cancelled, this should be
353 equal to each thr->ts.work_share, but otherwise it can be a possibly
354 long list of workshares. */
355 struct gomp_work_share *work_shares_to_free;
357 /* List of gomp_work_share structs chained through next_free fields.
358 This is populated and taken off only by the first thread in the
359 team encountering a new work sharing construct, in a critical
360 section. */
361 struct gomp_work_share *work_share_list_alloc;
363 /* List of gomp_work_share structs freed by free_work_share. New
364 entries are atomically added to the start of the list, and
365 alloc_work_share can safely only move all but the first entry
366 to work_share_list alloc, as free_work_share can happen concurrently
367 with alloc_work_share. */
368 struct gomp_work_share *work_share_list_free;
370 #ifdef HAVE_SYNC_BUILTINS
371 /* Number of simple single regions encountered by threads in this
372 team. */
373 unsigned long single_count;
374 #else
375 /* Mutex protecting addition of workshares to work_share_list_free. */
376 gomp_mutex_t work_share_list_free_lock;
377 #endif
379 /* This barrier is used for most synchronization of the team. */
380 gomp_barrier_t barrier;
382 /* Initial work shares, to avoid allocating any gomp_work_share
383 structs in the common case. */
384 struct gomp_work_share work_shares[8];
386 gomp_mutex_t task_lock;
387 struct gomp_task *task_queue;
388 /* Number of all GOMP_TASK_{WAITING,TIED} tasks in the team. */
389 unsigned int task_count;
390 /* Number of GOMP_TASK_WAITING tasks currently waiting to be scheduled. */
391 unsigned int task_queued_count;
392 /* Number of GOMP_TASK_{WAITING,TIED} tasks currently running
393 directly in gomp_barrier_handle_tasks; tasks spawned
394 from e.g. GOMP_taskwait or GOMP_taskgroup_end don't count, even when
395 that is called from a task run from gomp_barrier_handle_tasks.
396 task_running_count should be always <= team->nthreads,
397 and if current task isn't in_tied_task, then it will be
398 even < team->nthreads. */
399 unsigned int task_running_count;
400 int work_share_cancelled;
401 int team_cancelled;
403 /* This array contains structures for implicit tasks. */
404 struct gomp_task implicit_task[];
407 /* This structure contains all data that is private to libgomp and is
408 allocated per thread. */
410 struct gomp_thread
412 /* This is the function that the thread should run upon launch. */
413 void (*fn) (void *data);
414 void *data;
416 /* This is the current team state for this thread. The ts.team member
417 is NULL only if the thread is idle. */
418 struct gomp_team_state ts;
420 /* This is the task that the thread is currently executing. */
421 struct gomp_task *task;
423 /* This semaphore is used for ordered loops. */
424 gomp_sem_t release;
426 /* Place this thread is bound to plus one, or zero if not bound
427 to any place. */
428 unsigned int place;
430 /* User pthread thread pool */
431 struct gomp_thread_pool *thread_pool;
435 struct gomp_thread_pool
437 /* This array manages threads spawned from the top level, which will
438 return to the idle loop once the current PARALLEL construct ends. */
439 struct gomp_thread **threads;
440 unsigned threads_size;
441 unsigned threads_used;
442 struct gomp_team *last_team;
443 /* Number of threads running in this contention group. */
444 unsigned long threads_busy;
446 /* This barrier holds and releases threads waiting in threads. */
447 gomp_barrier_t threads_dock;
450 enum gomp_cancel_kind
452 GOMP_CANCEL_PARALLEL = 1,
453 GOMP_CANCEL_LOOP = 2,
454 GOMP_CANCEL_FOR = GOMP_CANCEL_LOOP,
455 GOMP_CANCEL_DO = GOMP_CANCEL_LOOP,
456 GOMP_CANCEL_SECTIONS = 4,
457 GOMP_CANCEL_TASKGROUP = 8
460 /* ... and here is that TLS data. */
462 #ifdef HAVE_TLS
463 extern __thread struct gomp_thread gomp_tls_data;
464 static inline struct gomp_thread *gomp_thread (void)
466 return &gomp_tls_data;
468 #else
469 extern pthread_key_t gomp_tls_key;
470 static inline struct gomp_thread *gomp_thread (void)
472 return pthread_getspecific (gomp_tls_key);
474 #endif
476 extern struct gomp_task_icv *gomp_new_icv (void);
478 /* Here's how to access the current copy of the ICVs. */
480 static inline struct gomp_task_icv *gomp_icv (bool write)
482 struct gomp_task *task = gomp_thread ()->task;
483 if (task)
484 return &task->icv;
485 else if (write)
486 return gomp_new_icv ();
487 else
488 return &gomp_global_icv;
491 /* The attributes to be used during thread creation. */
492 extern pthread_attr_t gomp_thread_attr;
494 /* Function prototypes. */
496 /* affinity.c */
498 extern void gomp_init_affinity (void);
499 extern void gomp_init_thread_affinity (pthread_attr_t *, unsigned int);
500 extern void **gomp_affinity_alloc (unsigned long, bool);
501 extern void gomp_affinity_init_place (void *);
502 extern bool gomp_affinity_add_cpus (void *, unsigned long, unsigned long,
503 long, bool);
504 extern bool gomp_affinity_remove_cpu (void *, unsigned long);
505 extern bool gomp_affinity_copy_place (void *, void *, long);
506 extern bool gomp_affinity_same_place (void *, void *);
507 extern bool gomp_affinity_finalize_place_list (bool);
508 extern bool gomp_affinity_init_level (int, unsigned long, bool);
509 extern void gomp_affinity_print_place (void *);
511 /* alloc.c */
513 extern void *gomp_malloc (size_t) __attribute__((malloc));
514 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc));
515 extern void *gomp_realloc (void *, size_t);
517 /* Avoid conflicting prototypes of alloca() in system headers by using
518 GCC's builtin alloca(). */
519 #define gomp_alloca(x) __builtin_alloca(x)
521 /* error.c */
523 extern void gomp_error (const char *, ...)
524 __attribute__((format (printf, 1, 2)));
525 extern void gomp_fatal (const char *, ...)
526 __attribute__((noreturn, format (printf, 1, 2)));
528 /* iter.c */
530 extern int gomp_iter_static_next (long *, long *);
531 extern bool gomp_iter_dynamic_next_locked (long *, long *);
532 extern bool gomp_iter_guided_next_locked (long *, long *);
534 #ifdef HAVE_SYNC_BUILTINS
535 extern bool gomp_iter_dynamic_next (long *, long *);
536 extern bool gomp_iter_guided_next (long *, long *);
537 #endif
539 /* iter_ull.c */
541 extern int gomp_iter_ull_static_next (unsigned long long *,
542 unsigned long long *);
543 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *,
544 unsigned long long *);
545 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *,
546 unsigned long long *);
548 #if defined HAVE_SYNC_BUILTINS && defined __LP64__
549 extern bool gomp_iter_ull_dynamic_next (unsigned long long *,
550 unsigned long long *);
551 extern bool gomp_iter_ull_guided_next (unsigned long long *,
552 unsigned long long *);
553 #endif
555 /* ordered.c */
557 extern void gomp_ordered_first (void);
558 extern void gomp_ordered_last (void);
559 extern void gomp_ordered_next (void);
560 extern void gomp_ordered_static_init (void);
561 extern void gomp_ordered_static_next (void);
562 extern void gomp_ordered_sync (void);
564 /* parallel.c */
566 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
568 /* proc.c (in config/) */
570 extern void gomp_init_num_threads (void);
571 extern unsigned gomp_dynamic_max_threads (void);
573 /* task.c */
575 extern void gomp_init_task (struct gomp_task *, struct gomp_task *,
576 struct gomp_task_icv *);
577 extern void gomp_end_task (void);
578 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t);
580 static void inline
581 gomp_finish_task (struct gomp_task *task)
583 if (__builtin_expect (task->depend_hash != NULL, 0))
584 free (task->depend_hash);
585 gomp_sem_destroy (&task->taskwait_sem);
588 /* team.c */
590 extern struct gomp_team *gomp_new_team (unsigned);
591 extern void gomp_team_start (void (*) (void *), void *, unsigned,
592 unsigned, struct gomp_team *);
593 extern void gomp_team_end (void);
594 extern void gomp_free_thread (void *);
596 /* target.c */
598 extern int gomp_get_num_devices (void);
600 /* work.c */
602 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned);
603 extern void gomp_fini_work_share (struct gomp_work_share *);
604 extern bool gomp_work_share_start (bool);
605 extern void gomp_work_share_end (void);
606 extern bool gomp_work_share_end_cancel (void);
607 extern void gomp_work_share_end_nowait (void);
609 static inline void
610 gomp_work_share_init_done (void)
612 struct gomp_thread *thr = gomp_thread ();
613 if (__builtin_expect (thr->ts.last_work_share != NULL, 1))
614 gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share);
617 #ifdef HAVE_ATTRIBUTE_VISIBILITY
618 # pragma GCC visibility pop
619 #endif
621 /* Now that we're back to default visibility, include the globals. */
622 #include "libgomp_g.h"
624 /* Include omp.h by parts. */
625 #include "omp-lock.h"
626 #define _LIBGOMP_OMP_LOCK_DEFINED 1
627 #include "omp.h.in"
629 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \
630 || !defined (HAVE_ATTRIBUTE_ALIAS) \
631 || !defined (HAVE_AS_SYMVER_DIRECTIVE) \
632 || !defined (PIC) \
633 || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT)
634 # undef LIBGOMP_GNU_SYMBOL_VERSIONING
635 #endif
637 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
638 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
639 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
640 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
641 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
642 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW;
643 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
644 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
645 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
646 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
647 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW;
649 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
650 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
651 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
652 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
653 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW;
654 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
655 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
656 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
657 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
658 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW;
660 # define strong_alias(fn, al) \
661 extern __typeof (fn) al __attribute__ ((alias (#fn)));
662 # define omp_lock_symver(fn) \
663 __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \
664 __asm (".symver g" #fn "_25, " #fn "@OMP_1.0");
665 #else
666 # define gomp_init_lock_30 omp_init_lock
667 # define gomp_destroy_lock_30 omp_destroy_lock
668 # define gomp_set_lock_30 omp_set_lock
669 # define gomp_unset_lock_30 omp_unset_lock
670 # define gomp_test_lock_30 omp_test_lock
671 # define gomp_init_nest_lock_30 omp_init_nest_lock
672 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock
673 # define gomp_set_nest_lock_30 omp_set_nest_lock
674 # define gomp_unset_nest_lock_30 omp_unset_nest_lock
675 # define gomp_test_nest_lock_30 omp_test_nest_lock
676 #endif
678 #ifdef HAVE_ATTRIBUTE_VISIBILITY
679 # define attribute_hidden __attribute__ ((visibility ("hidden")))
680 #else
681 # define attribute_hidden
682 #endif
684 #ifdef HAVE_ATTRIBUTE_ALIAS
685 # define ialias_ulp ialias_str1(__USER_LABEL_PREFIX__)
686 # define ialias_str1(x) ialias_str2(x)
687 # define ialias_str2(x) #x
688 # define ialias(fn) \
689 extern __typeof (fn) gomp_ialias_##fn \
690 __attribute__ ((alias (#fn))) attribute_hidden;
691 # define ialias_redirect(fn) \
692 extern __typeof (fn) fn __asm__ (ialias_ulp "gomp_ialias_" #fn) attribute_hidden;
693 # define ialias_call(fn) gomp_ialias_ ## fn
694 #else
695 # define ialias(fn)
696 # define ialias_redirect(fn)
697 # define ialias_call(fn) fn
698 #endif
700 #endif /* LIBGOMP_H */