Mercurial > hg > CbC > CbC_gcc
annotate libgomp/libgomp.h @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
| author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 22 Mar 2011 17:18:12 +0900 |
| parents | a06113de4d67 |
| children | 04ced10e8804 |
| rev | line source |
|---|---|
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1 /* Copyright (C) 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. |
| 0 | 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 | |
| 43 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 44 # pragma GCC visibility push(hidden) | |
| 45 #endif | |
| 46 | |
| 47 #include "sem.h" | |
| 48 #include "mutex.h" | |
| 49 #include "bar.h" | |
| 50 #include "ptrlock.h" | |
| 51 | |
| 52 | |
| 53 /* This structure contains the data to control one work-sharing construct, | |
| 54 either a LOOP (FOR/DO) or a SECTIONS. */ | |
| 55 | |
| 56 enum gomp_schedule_type | |
| 57 { | |
| 58 GFS_RUNTIME, | |
| 59 GFS_STATIC, | |
| 60 GFS_DYNAMIC, | |
| 61 GFS_GUIDED, | |
| 62 GFS_AUTO | |
| 63 }; | |
| 64 | |
| 65 struct gomp_work_share | |
| 66 { | |
| 67 /* This member records the SCHEDULE clause to be used for this construct. | |
| 68 The user specification of "runtime" will already have been resolved. | |
| 69 If this is a SECTIONS construct, this value will always be DYNAMIC. */ | |
| 70 enum gomp_schedule_type sched; | |
| 71 | |
| 72 int mode; | |
| 73 | |
| 74 union { | |
| 75 struct { | |
| 76 /* This is the chunk_size argument to the SCHEDULE clause. */ | |
| 77 long chunk_size; | |
| 78 | |
| 79 /* This is the iteration end point. If this is a SECTIONS construct, | |
| 80 this is the number of contained sections. */ | |
| 81 long end; | |
| 82 | |
| 83 /* This is the iteration step. If this is a SECTIONS construct, this | |
| 84 is always 1. */ | |
| 85 long incr; | |
| 86 }; | |
| 87 | |
| 88 struct { | |
| 89 /* The same as above, but for the unsigned long long loop variants. */ | |
| 90 unsigned long long chunk_size_ull; | |
| 91 unsigned long long end_ull; | |
| 92 unsigned long long incr_ull; | |
| 93 }; | |
| 94 }; | |
| 95 | |
| 96 /* This is a circular queue that details which threads will be allowed | |
| 97 into the ordered region and in which order. When a thread allocates | |
| 98 iterations on which it is going to work, it also registers itself at | |
| 99 the end of the array. When a thread reaches the ordered region, it | |
| 100 checks to see if it is the one at the head of the queue. If not, it | |
| 101 blocks on its RELEASE semaphore. */ | |
| 102 unsigned *ordered_team_ids; | |
| 103 | |
| 104 /* This is the number of threads that have registered themselves in | |
| 105 the circular queue ordered_team_ids. */ | |
| 106 unsigned ordered_num_used; | |
| 107 | |
| 108 /* This is the team_id of the currently acknowledged owner of the ordered | |
| 109 section, or -1u if the ordered section has not been acknowledged by | |
| 110 any thread. This is distinguished from the thread that is *allowed* | |
| 111 to take the section next. */ | |
| 112 unsigned ordered_owner; | |
| 113 | |
| 114 /* This is the index into the circular queue ordered_team_ids of the | |
| 115 current thread that's allowed into the ordered reason. */ | |
| 116 unsigned ordered_cur; | |
| 117 | |
| 118 /* This is a chain of allocated gomp_work_share blocks, valid only | |
| 119 in the first gomp_work_share struct in the block. */ | |
| 120 struct gomp_work_share *next_alloc; | |
| 121 | |
| 122 /* The above fields are written once during workshare initialization, | |
| 123 or related to ordered worksharing. Make sure the following fields | |
| 124 are in a different cache line. */ | |
| 125 | |
| 126 /* This lock protects the update of the following members. */ | |
| 127 gomp_mutex_t lock __attribute__((aligned (64))); | |
| 128 | |
| 129 /* This is the count of the number of threads that have exited the work | |
| 130 share construct. If the construct was marked nowait, they have moved on | |
| 131 to other work; otherwise they're blocked on a barrier. The last member | |
| 132 of the team to exit the work share construct must deallocate it. */ | |
| 133 unsigned threads_completed; | |
| 134 | |
| 135 union { | |
| 136 /* This is the next iteration value to be allocated. In the case of | |
| 137 GFS_STATIC loops, this the iteration start point and never changes. */ | |
| 138 long next; | |
| 139 | |
| 140 /* The same, but with unsigned long long type. */ | |
| 141 unsigned long long next_ull; | |
| 142 | |
| 143 /* This is the returned data structure for SINGLE COPYPRIVATE. */ | |
| 144 void *copyprivate; | |
| 145 }; | |
| 146 | |
| 147 union { | |
| 148 /* Link to gomp_work_share struct for next work sharing construct | |
| 149 encountered after this one. */ | |
| 150 gomp_ptrlock_t next_ws; | |
| 151 | |
| 152 /* gomp_work_share structs are chained in the free work share cache | |
| 153 through this. */ | |
| 154 struct gomp_work_share *next_free; | |
| 155 }; | |
| 156 | |
| 157 /* If only few threads are in the team, ordered_team_ids can point | |
| 158 to this array which fills the padding at the end of this struct. */ | |
| 159 unsigned inline_ordered_team_ids[0]; | |
| 160 }; | |
| 161 | |
| 162 /* This structure contains all of the thread-local data associated with | |
| 163 a thread team. This is the data that must be saved when a thread | |
| 164 encounters a nested PARALLEL construct. */ | |
| 165 | |
| 166 struct gomp_team_state | |
| 167 { | |
| 168 /* This is the team of which the thread is currently a member. */ | |
| 169 struct gomp_team *team; | |
| 170 | |
| 171 /* This is the work share construct which this thread is currently | |
| 172 processing. Recall that with NOWAIT, not all threads may be | |
| 173 processing the same construct. */ | |
| 174 struct gomp_work_share *work_share; | |
| 175 | |
| 176 /* This is the previous work share construct or NULL if there wasn't any. | |
| 177 When all threads are done with the current work sharing construct, | |
| 178 the previous one can be freed. The current one can't, as its | |
| 179 next_ws field is used. */ | |
| 180 struct gomp_work_share *last_work_share; | |
| 181 | |
| 182 /* This is the ID of this thread within the team. This value is | |
| 183 guaranteed to be between 0 and N-1, where N is the number of | |
| 184 threads in the team. */ | |
| 185 unsigned team_id; | |
| 186 | |
| 187 /* Nesting level. */ | |
| 188 unsigned level; | |
| 189 | |
| 190 /* Active nesting level. Only active parallel regions are counted. */ | |
| 191 unsigned active_level; | |
| 192 | |
| 193 #ifdef HAVE_SYNC_BUILTINS | |
| 194 /* Number of single stmts encountered. */ | |
| 195 unsigned long single_count; | |
| 196 #endif | |
| 197 | |
| 198 /* For GFS_RUNTIME loops that resolved to GFS_STATIC, this is the | |
| 199 trip number through the loop. So first time a particular loop | |
| 200 is encountered this number is 0, the second time through the loop | |
| 201 is 1, etc. This is unused when the compiler knows in advance that | |
| 202 the loop is statically scheduled. */ | |
| 203 unsigned long static_trip; | |
| 204 }; | |
| 205 | |
| 206 /* These are the OpenMP 3.0 Internal Control Variables described in | |
| 207 section 2.3.1. Those described as having one copy per task are | |
| 208 stored within the structure; those described as having one copy | |
| 209 for the whole program are (naturally) global variables. */ | |
| 210 | |
| 211 struct gomp_task_icv | |
| 212 { | |
| 213 unsigned long nthreads_var; | |
| 214 enum gomp_schedule_type run_sched_var; | |
| 215 int run_sched_modifier; | |
| 216 bool dyn_var; | |
| 217 bool nest_var; | |
| 218 }; | |
| 219 | |
| 220 extern struct gomp_task_icv gomp_global_icv; | |
| 221 extern unsigned long gomp_thread_limit_var; | |
| 222 extern unsigned long gomp_remaining_threads_count; | |
| 223 #ifndef HAVE_SYNC_BUILTINS | |
| 224 extern gomp_mutex_t gomp_remaining_threads_lock; | |
| 225 #endif | |
| 226 extern unsigned long gomp_max_active_levels_var; | |
| 227 extern unsigned long long gomp_spin_count_var, gomp_throttled_spin_count_var; | |
| 228 extern unsigned long gomp_available_cpus, gomp_managed_threads; | |
| 229 | |
| 230 enum gomp_task_kind | |
| 231 { | |
| 232 GOMP_TASK_IMPLICIT, | |
| 233 GOMP_TASK_IFFALSE, | |
| 234 GOMP_TASK_WAITING, | |
| 235 GOMP_TASK_TIED | |
| 236 }; | |
| 237 | |
| 238 /* This structure describes a "task" to be run by a thread. */ | |
| 239 | |
| 240 struct gomp_task | |
| 241 { | |
| 242 struct gomp_task *parent; | |
| 243 struct gomp_task *children; | |
| 244 struct gomp_task *next_child; | |
| 245 struct gomp_task *prev_child; | |
| 246 struct gomp_task *next_queue; | |
| 247 struct gomp_task *prev_queue; | |
| 248 struct gomp_task_icv icv; | |
| 249 void (*fn) (void *); | |
| 250 void *fn_data; | |
| 251 enum gomp_task_kind kind; | |
| 252 bool in_taskwait; | |
| 253 bool in_tied_task; | |
| 254 gomp_sem_t taskwait_sem; | |
| 255 }; | |
| 256 | |
| 257 /* This structure describes a "team" of threads. These are the threads | |
| 258 that are spawned by a PARALLEL constructs, as well as the work sharing | |
| 259 constructs that the team encounters. */ | |
| 260 | |
| 261 struct gomp_team | |
| 262 { | |
| 263 /* This is the number of threads in the current team. */ | |
| 264 unsigned nthreads; | |
| 265 | |
| 266 /* This is number of gomp_work_share structs that have been allocated | |
| 267 as a block last time. */ | |
| 268 unsigned work_share_chunk; | |
| 269 | |
| 270 /* This is the saved team state that applied to a master thread before | |
| 271 the current thread was created. */ | |
| 272 struct gomp_team_state prev_ts; | |
| 273 | |
| 274 /* This semaphore should be used by the master thread instead of its | |
| 275 "native" semaphore in the thread structure. Required for nested | |
| 276 parallels, as the master is a member of two teams. */ | |
| 277 gomp_sem_t master_release; | |
| 278 | |
| 279 /* This points to an array with pointers to the release semaphore | |
| 280 of the threads in the team. */ | |
| 281 gomp_sem_t **ordered_release; | |
| 282 | |
| 283 /* List of gomp_work_share structs chained through next_free fields. | |
| 284 This is populated and taken off only by the first thread in the | |
| 285 team encountering a new work sharing construct, in a critical | |
| 286 section. */ | |
| 287 struct gomp_work_share *work_share_list_alloc; | |
| 288 | |
| 289 /* List of gomp_work_share structs freed by free_work_share. New | |
| 290 entries are atomically added to the start of the list, and | |
| 291 alloc_work_share can safely only move all but the first entry | |
| 292 to work_share_list alloc, as free_work_share can happen concurrently | |
| 293 with alloc_work_share. */ | |
| 294 struct gomp_work_share *work_share_list_free; | |
| 295 | |
| 296 #ifdef HAVE_SYNC_BUILTINS | |
| 297 /* Number of simple single regions encountered by threads in this | |
| 298 team. */ | |
| 299 unsigned long single_count; | |
| 300 #else | |
| 301 /* Mutex protecting addition of workshares to work_share_list_free. */ | |
| 302 gomp_mutex_t work_share_list_free_lock; | |
| 303 #endif | |
| 304 | |
| 305 /* This barrier is used for most synchronization of the team. */ | |
| 306 gomp_barrier_t barrier; | |
| 307 | |
| 308 /* Initial work shares, to avoid allocating any gomp_work_share | |
| 309 structs in the common case. */ | |
| 310 struct gomp_work_share work_shares[8]; | |
| 311 | |
| 312 gomp_mutex_t task_lock; | |
| 313 struct gomp_task *task_queue; | |
| 314 int task_count; | |
| 315 int task_running_count; | |
| 316 | |
| 317 /* This array contains structures for implicit tasks. */ | |
| 318 struct gomp_task implicit_task[]; | |
| 319 }; | |
| 320 | |
| 321 /* This structure contains all data that is private to libgomp and is | |
| 322 allocated per thread. */ | |
| 323 | |
| 324 struct gomp_thread | |
| 325 { | |
| 326 /* This is the function that the thread should run upon launch. */ | |
| 327 void (*fn) (void *data); | |
| 328 void *data; | |
| 329 | |
| 330 /* This is the current team state for this thread. The ts.team member | |
| 331 is NULL only if the thread is idle. */ | |
| 332 struct gomp_team_state ts; | |
| 333 | |
| 334 /* This is the task that the thread is currently executing. */ | |
| 335 struct gomp_task *task; | |
| 336 | |
| 337 /* This semaphore is used for ordered loops. */ | |
| 338 gomp_sem_t release; | |
| 339 | |
| 340 /* user pthread thread pool */ | |
| 341 struct gomp_thread_pool *thread_pool; | |
| 342 }; | |
| 343 | |
| 344 | |
| 345 struct gomp_thread_pool | |
| 346 { | |
| 347 /* This array manages threads spawned from the top level, which will | |
| 348 return to the idle loop once the current PARALLEL construct ends. */ | |
| 349 struct gomp_thread **threads; | |
| 350 unsigned threads_size; | |
| 351 unsigned threads_used; | |
| 352 struct gomp_team *last_team; | |
| 353 | |
| 354 /* This barrier holds and releases threads waiting in threads. */ | |
| 355 gomp_barrier_t threads_dock; | |
| 356 }; | |
| 357 | |
| 358 /* ... and here is that TLS data. */ | |
| 359 | |
| 360 #ifdef HAVE_TLS | |
| 361 extern __thread struct gomp_thread gomp_tls_data; | |
| 362 static inline struct gomp_thread *gomp_thread (void) | |
| 363 { | |
| 364 return &gomp_tls_data; | |
| 365 } | |
| 366 #else | |
| 367 extern pthread_key_t gomp_tls_key; | |
| 368 static inline struct gomp_thread *gomp_thread (void) | |
| 369 { | |
| 370 return pthread_getspecific (gomp_tls_key); | |
| 371 } | |
| 372 #endif | |
| 373 | |
| 374 extern struct gomp_task_icv *gomp_new_icv (void); | |
| 375 | |
| 376 /* Here's how to access the current copy of the ICVs. */ | |
| 377 | |
| 378 static inline struct gomp_task_icv *gomp_icv (bool write) | |
| 379 { | |
| 380 struct gomp_task *task = gomp_thread ()->task; | |
| 381 if (task) | |
| 382 return &task->icv; | |
| 383 else if (write) | |
| 384 return gomp_new_icv (); | |
| 385 else | |
| 386 return &gomp_global_icv; | |
| 387 } | |
| 388 | |
| 389 /* The attributes to be used during thread creation. */ | |
| 390 extern pthread_attr_t gomp_thread_attr; | |
| 391 | |
| 392 /* Other variables. */ | |
| 393 | |
| 394 extern unsigned short *gomp_cpu_affinity; | |
| 395 extern size_t gomp_cpu_affinity_len; | |
| 396 | |
| 397 /* Function prototypes. */ | |
| 398 | |
| 399 /* affinity.c */ | |
| 400 | |
| 401 extern void gomp_init_affinity (void); | |
| 402 extern void gomp_init_thread_affinity (pthread_attr_t *); | |
| 403 | |
| 404 /* alloc.c */ | |
| 405 | |
| 406 extern void *gomp_malloc (size_t) __attribute__((malloc)); | |
| 407 extern void *gomp_malloc_cleared (size_t) __attribute__((malloc)); | |
| 408 extern void *gomp_realloc (void *, size_t); | |
| 409 | |
| 410 /* Avoid conflicting prototypes of alloca() in system headers by using | |
| 411 GCC's builtin alloca(). */ | |
| 412 #define gomp_alloca(x) __builtin_alloca(x) | |
| 413 | |
| 414 /* error.c */ | |
| 415 | |
| 416 extern void gomp_error (const char *, ...) | |
| 417 __attribute__((format (printf, 1, 2))); | |
| 418 extern void gomp_fatal (const char *, ...) | |
| 419 __attribute__((noreturn, format (printf, 1, 2))); | |
| 420 | |
| 421 /* iter.c */ | |
| 422 | |
| 423 extern int gomp_iter_static_next (long *, long *); | |
| 424 extern bool gomp_iter_dynamic_next_locked (long *, long *); | |
| 425 extern bool gomp_iter_guided_next_locked (long *, long *); | |
| 426 | |
| 427 #ifdef HAVE_SYNC_BUILTINS | |
| 428 extern bool gomp_iter_dynamic_next (long *, long *); | |
| 429 extern bool gomp_iter_guided_next (long *, long *); | |
| 430 #endif | |
| 431 | |
| 432 /* iter_ull.c */ | |
| 433 | |
| 434 extern int gomp_iter_ull_static_next (unsigned long long *, | |
| 435 unsigned long long *); | |
| 436 extern bool gomp_iter_ull_dynamic_next_locked (unsigned long long *, | |
| 437 unsigned long long *); | |
| 438 extern bool gomp_iter_ull_guided_next_locked (unsigned long long *, | |
| 439 unsigned long long *); | |
| 440 | |
| 441 #if defined HAVE_SYNC_BUILTINS && defined __LP64__ | |
| 442 extern bool gomp_iter_ull_dynamic_next (unsigned long long *, | |
| 443 unsigned long long *); | |
| 444 extern bool gomp_iter_ull_guided_next (unsigned long long *, | |
| 445 unsigned long long *); | |
| 446 #endif | |
| 447 | |
| 448 /* ordered.c */ | |
| 449 | |
| 450 extern void gomp_ordered_first (void); | |
| 451 extern void gomp_ordered_last (void); | |
| 452 extern void gomp_ordered_next (void); | |
| 453 extern void gomp_ordered_static_init (void); | |
| 454 extern void gomp_ordered_static_next (void); | |
| 455 extern void gomp_ordered_sync (void); | |
| 456 | |
| 457 /* parallel.c */ | |
| 458 | |
| 459 extern unsigned gomp_resolve_num_threads (unsigned, unsigned); | |
| 460 | |
| 461 /* proc.c (in config/) */ | |
| 462 | |
| 463 extern void gomp_init_num_threads (void); | |
| 464 extern unsigned gomp_dynamic_max_threads (void); | |
| 465 | |
| 466 /* task.c */ | |
| 467 | |
| 468 extern void gomp_init_task (struct gomp_task *, struct gomp_task *, | |
| 469 struct gomp_task_icv *); | |
| 470 extern void gomp_end_task (void); | |
| 471 extern void gomp_barrier_handle_tasks (gomp_barrier_state_t); | |
| 472 | |
| 473 static void inline | |
| 474 gomp_finish_task (struct gomp_task *task) | |
| 475 { | |
| 476 gomp_sem_destroy (&task->taskwait_sem); | |
| 477 } | |
| 478 | |
| 479 /* team.c */ | |
| 480 | |
| 481 extern struct gomp_team *gomp_new_team (unsigned); | |
| 482 extern void gomp_team_start (void (*) (void *), void *, unsigned, | |
| 483 struct gomp_team *); | |
| 484 extern void gomp_team_end (void); | |
| 485 | |
| 486 /* work.c */ | |
| 487 | |
| 488 extern void gomp_init_work_share (struct gomp_work_share *, bool, unsigned); | |
| 489 extern void gomp_fini_work_share (struct gomp_work_share *); | |
| 490 extern bool gomp_work_share_start (bool); | |
| 491 extern void gomp_work_share_end (void); | |
| 492 extern void gomp_work_share_end_nowait (void); | |
| 493 | |
| 494 static inline void | |
| 495 gomp_work_share_init_done (void) | |
| 496 { | |
| 497 struct gomp_thread *thr = gomp_thread (); | |
| 498 if (__builtin_expect (thr->ts.last_work_share != NULL, 1)) | |
| 499 gomp_ptrlock_set (&thr->ts.last_work_share->next_ws, thr->ts.work_share); | |
| 500 } | |
| 501 | |
| 502 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 503 # pragma GCC visibility pop | |
| 504 #endif | |
| 505 | |
| 506 /* Now that we're back to default visibility, include the globals. */ | |
| 507 #include "libgomp_g.h" | |
| 508 | |
| 509 /* Include omp.h by parts. */ | |
| 510 #include "omp-lock.h" | |
| 511 #define _LIBGOMP_OMP_LOCK_DEFINED 1 | |
| 512 #include "omp.h.in" | |
| 513 | |
| 514 #if !defined (HAVE_ATTRIBUTE_VISIBILITY) \ | |
| 515 || !defined (HAVE_ATTRIBUTE_ALIAS) \ | |
| 516 || !defined (HAVE_AS_SYMVER_DIRECTIVE) \ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
517 || !defined (PIC) \ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
518 || !defined (HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT) |
| 0 | 519 # undef LIBGOMP_GNU_SYMBOL_VERSIONING |
| 520 #endif | |
| 521 | |
| 522 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING | |
| 523 extern void gomp_init_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 524 extern void gomp_destroy_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 525 extern void gomp_set_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 526 extern void gomp_unset_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 527 extern int gomp_test_lock_30 (omp_lock_t *) __GOMP_NOTHROW; | |
| 528 extern void gomp_init_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 529 extern void gomp_destroy_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 530 extern void gomp_set_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 531 extern void gomp_unset_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 532 extern int gomp_test_nest_lock_30 (omp_nest_lock_t *) __GOMP_NOTHROW; | |
| 533 | |
| 534 extern void gomp_init_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 535 extern void gomp_destroy_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 536 extern void gomp_set_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 537 extern void gomp_unset_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 538 extern int gomp_test_lock_25 (omp_lock_25_t *) __GOMP_NOTHROW; | |
| 539 extern void gomp_init_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 540 extern void gomp_destroy_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 541 extern void gomp_set_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 542 extern void gomp_unset_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 543 extern int gomp_test_nest_lock_25 (omp_nest_lock_25_t *) __GOMP_NOTHROW; | |
| 544 | |
| 545 # define strong_alias(fn, al) \ | |
| 546 extern __typeof (fn) al __attribute__ ((alias (#fn))); | |
| 547 # define omp_lock_symver(fn) \ | |
| 548 __asm (".symver g" #fn "_30, " #fn "@@OMP_3.0"); \ | |
| 549 __asm (".symver g" #fn "_25, " #fn "@OMP_1.0"); | |
| 550 #else | |
| 551 # define gomp_init_lock_30 omp_init_lock | |
| 552 # define gomp_destroy_lock_30 omp_destroy_lock | |
| 553 # define gomp_set_lock_30 omp_set_lock | |
| 554 # define gomp_unset_lock_30 omp_unset_lock | |
| 555 # define gomp_test_lock_30 omp_test_lock | |
| 556 # define gomp_init_nest_lock_30 omp_init_nest_lock | |
| 557 # define gomp_destroy_nest_lock_30 omp_destroy_nest_lock | |
| 558 # define gomp_set_nest_lock_30 omp_set_nest_lock | |
| 559 # define gomp_unset_nest_lock_30 omp_unset_nest_lock | |
| 560 # define gomp_test_nest_lock_30 omp_test_nest_lock | |
| 561 #endif | |
| 562 | |
| 563 #ifdef HAVE_ATTRIBUTE_VISIBILITY | |
| 564 # define attribute_hidden __attribute__ ((visibility ("hidden"))) | |
| 565 #else | |
| 566 # define attribute_hidden | |
| 567 #endif | |
| 568 | |
| 569 #ifdef HAVE_ATTRIBUTE_ALIAS | |
| 570 # define ialias(fn) \ | |
| 571 extern __typeof (fn) gomp_ialias_##fn \ | |
| 572 __attribute__ ((alias (#fn))) attribute_hidden; | |
| 573 #else | |
| 574 # define ialias(fn) | |
| 575 #endif | |
| 576 | |
| 577 #endif /* LIBGOMP_H */ |