libgomp/libgomp.h

   1 /* Copyright (C) 2005-2013 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 };
 278
 279 struct gomp_dependers_vec
 280 {
 281   size_t n_elem;
 282   size_t allocated;
 283   struct gomp_task *elem[];
 284 };
 285
 286 /* This structure describes a "task" to be run by a thread.  */
 287
 288 struct gomp_task
 289 {
 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[];
 313 };
 314
 315 struct gomp_taskgroup
 316 {
 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;
 323 };
 324
 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.  */
 328
 329 struct gomp_team
 330 {
 331   /* This is the number of threads in the current team.  */
 332   unsigned nthreads;
 333
 334   /* This is number of gomp_work_share structs that have been allocated
 335      as a block last time.  */
 336   unsigned work_share_chunk;
 337
 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;
 341
 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;
 346
 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;
 350
 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;
 356
 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;
 362
 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;
 369
 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
 378
 379   /* This barrier is used for most synchronization of the team.  */
 380   gomp_barrier_t barrier;
 381
 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];
 385
 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;
 402
 403   /* This array contains structures for implicit tasks.  */
 404   struct gomp_task implicit_task[];
 405 };
 406
 407 /* This structure contains all data that is private to libgomp and is
 408    allocated per thread.  */
 409
 410 struct gomp_thread
 411 {
 412   /* This is the function that the thread should run upon launch.  */
 413   void (*fn) (void *data);
 414   void *data;
 415
 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;
 419
 420   /* This is the task that the thread is currently executing.  */
 421   struct gomp_task *task;
 422
 423   /* This semaphore is used for ordered loops.  */
 424   gomp_sem_t release;
 425
 426   /* Place this thread is bound to plus one, or zero if not bound
 427      to any place.  */
 428   unsigned int place;
 429
 430   /* User pthread thread pool */
 431   struct gomp_thread_pool *thread_pool;
 432 };
 433
 434
 435 struct gomp_thread_pool
 436 {
 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;
 445
 446   /* This barrier holds and releases threads waiting in threads.  */
 447   gomp_barrier_t threads_dock;
 448 };
 449
 450 enum gomp_cancel_kind
 451 {
 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
 458 };
 459
 460 /* ... and here is that TLS data.  */
 461
 462 #ifdef HAVE_TLS
 463 extern __thread struct gomp_thread gomp_tls_data;
 464 static inline struct gomp_thread *gomp_thread (void)
 465 {
 466   return &gomp_tls_data;
 467 }
 468 #else
 469 extern pthread_key_t gomp_tls_key;
 470 static inline struct gomp_thread *gomp_thread (void)
 471 {
 472   return pthread_getspecific (gomp_tls_key);
 473 }
 474 #endif
 475
 476 extern struct gomp_task_icv *gomp_new_icv (void);
 477
 478 /* Here's how to access the current copy of the ICVs.  */
 479
 480 static inline struct gomp_task_icv *gomp_icv (bool write)
 481 {
 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;
 489 }
 490
 491 /* The attributes to be used during thread creation.  */
 492 extern pthread_attr_t gomp_thread_attr;
 493
 494 /* Function prototypes.  */
 495
 496 /* affinity.c */
 497
 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 *);
 510
 511 /* alloc.c */
 512
 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);
 516
 517 /* Avoid conflicting prototypes of alloca() in system headers by using
 518    GCC's builtin alloca().  */
 519 #define gomp_alloca(x)  __builtin_alloca(x)
 520
 521 /* error.c */
 522
 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)));
 527
 528 /* iter.c */
 529
 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 *);
 533
 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
 538
 539 /* iter_ull.c */
 540
 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 *);
 547
 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
 554
 555 /* ordered.c */
 556
 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);
 563
 564 /* parallel.c */
 565
 566 extern unsigned gomp_resolve_num_threads (unsigned, unsigned);
 567
 568 /* proc.c (in config/) */
 569
 570 extern void gomp_init_num_threads (void);
 571 extern unsigned gomp_dynamic_max_threads (void);
 572
 573 /* task.c */
 574
 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);
 579
 580 static void inline
 581 gomp_finish_task (struct gomp_task *task)
 582 {
 583   if (__builtin_expect (task->depend_hash != NULL, 0))
 584     free (task->depend_hash);
 585   gomp_sem_destroy (&task->taskwait_sem);
 586 }
 587
 588 /* team.c */
 589
 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 *);
 595
 596 /* target.c */
 597
 598 extern int gomp_get_num_devices (void);
 599
 600 /* work.c */
 601
 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);
 608
 609 static inline void
 610 gomp_work_share_init_done (void)
 611 {
 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);
 615 }
 616
 617 #ifdef HAVE_ATTRIBUTE_VISIBILITY
 618 # pragma GCC visibility pop
 619 #endif
 620
 621 /* Now that we're back to default visibility, include the globals.  */
 622 #include "libgomp_g.h"
 623
 624 /* Include omp.h by parts.  */
 625 #include "omp-lock.h"
 626 #define _LIBGOMP_OMP_LOCK_DEFINED 1
 627 #include "omp.h.in"
 628
 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
 636
 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;
 648
 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;
 659
 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
 677
 678 #ifdef HAVE_ATTRIBUTE_VISIBILITY
 679 # define attribute_hidden __attribute__ ((visibility ("hidden")))
 680 #else
 681 # define attribute_hidden
 682 #endif
 683
 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
 699
 700 #endif /* LIBGOMP_H */