libgomp/libgomp.h

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