]>
Commit | Line | Data |
---|---|---|
1 | /* Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc. | |
2 | Contributed by Jakub Jelinek <jakub@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 Fortran wrapper routines. */ | |
26 | ||
27 | #include "libgomp.h" | |
28 | #include "libgomp_f.h" | |
29 | #include <stdlib.h> | |
30 | ||
31 | #ifdef HAVE_ATTRIBUTE_ALIAS | |
32 | /* Use internal aliases if possible. */ | |
33 | # define ULP STR1(__USER_LABEL_PREFIX__) | |
34 | # define STR1(x) STR2(x) | |
35 | # define STR2(x) #x | |
36 | # define ialias_redirect(fn) \ | |
37 | extern __typeof (fn) fn __asm__ (ULP "gomp_ialias_" #fn) attribute_hidden; | |
38 | # ifndef LIBGOMP_GNU_SYMBOL_VERSIONING | |
39 | ialias_redirect (omp_init_lock) | |
40 | ialias_redirect (omp_init_nest_lock) | |
41 | ialias_redirect (omp_destroy_lock) | |
42 | ialias_redirect (omp_destroy_nest_lock) | |
43 | ialias_redirect (omp_set_lock) | |
44 | ialias_redirect (omp_set_nest_lock) | |
45 | ialias_redirect (omp_unset_lock) | |
46 | ialias_redirect (omp_unset_nest_lock) | |
47 | ialias_redirect (omp_test_lock) | |
48 | ialias_redirect (omp_test_nest_lock) | |
49 | # endif | |
50 | ialias_redirect (omp_set_dynamic) | |
51 | ialias_redirect (omp_set_nested) | |
52 | ialias_redirect (omp_set_num_threads) | |
53 | ialias_redirect (omp_get_dynamic) | |
54 | ialias_redirect (omp_get_nested) | |
55 | ialias_redirect (omp_in_parallel) | |
56 | ialias_redirect (omp_get_max_threads) | |
57 | ialias_redirect (omp_get_num_procs) | |
58 | ialias_redirect (omp_get_num_threads) | |
59 | ialias_redirect (omp_get_thread_num) | |
60 | ialias_redirect (omp_get_wtick) | |
61 | ialias_redirect (omp_get_wtime) | |
62 | ialias_redirect (omp_set_schedule) | |
63 | ialias_redirect (omp_get_schedule) | |
64 | ialias_redirect (omp_get_thread_limit) | |
65 | ialias_redirect (omp_set_max_active_levels) | |
66 | ialias_redirect (omp_get_max_active_levels) | |
67 | ialias_redirect (omp_get_level) | |
68 | ialias_redirect (omp_get_ancestor_thread_num) | |
69 | ialias_redirect (omp_get_team_size) | |
70 | ialias_redirect (omp_get_active_level) | |
71 | #endif | |
72 | ||
73 | #ifndef LIBGOMP_GNU_SYMBOL_VERSIONING | |
74 | # define gomp_init_lock__30 omp_init_lock_ | |
75 | # define gomp_destroy_lock__30 omp_destroy_lock_ | |
76 | # define gomp_set_lock__30 omp_set_lock_ | |
77 | # define gomp_unset_lock__30 omp_unset_lock_ | |
78 | # define gomp_test_lock__30 omp_test_lock_ | |
79 | # define gomp_init_nest_lock__30 omp_init_nest_lock_ | |
80 | # define gomp_destroy_nest_lock__30 omp_destroy_nest_lock_ | |
81 | # define gomp_set_nest_lock__30 omp_set_nest_lock_ | |
82 | # define gomp_unset_nest_lock__30 omp_unset_nest_lock_ | |
83 | # define gomp_test_nest_lock__30 omp_test_nest_lock_ | |
84 | #endif | |
85 | ||
86 | void | |
87 | gomp_init_lock__30 (omp_lock_arg_t lock) | |
88 | { | |
89 | #ifndef OMP_LOCK_DIRECT | |
90 | omp_lock_arg (lock) = malloc (sizeof (omp_lock_t)); | |
91 | #endif | |
92 | gomp_init_lock_30 (omp_lock_arg (lock)); | |
93 | } | |
94 | ||
95 | void | |
96 | gomp_init_nest_lock__30 (omp_nest_lock_arg_t lock) | |
97 | { | |
98 | #ifndef OMP_NEST_LOCK_DIRECT | |
99 | omp_nest_lock_arg (lock) = malloc (sizeof (omp_nest_lock_t)); | |
100 | #endif | |
101 | gomp_init_nest_lock_30 (omp_nest_lock_arg (lock)); | |
102 | } | |
103 | ||
104 | void | |
105 | gomp_destroy_lock__30 (omp_lock_arg_t lock) | |
106 | { | |
107 | gomp_destroy_lock_30 (omp_lock_arg (lock)); | |
108 | #ifndef OMP_LOCK_DIRECT | |
109 | free (omp_lock_arg (lock)); | |
110 | omp_lock_arg (lock) = NULL; | |
111 | #endif | |
112 | } | |
113 | ||
114 | void | |
115 | gomp_destroy_nest_lock__30 (omp_nest_lock_arg_t lock) | |
116 | { | |
117 | gomp_destroy_nest_lock_30 (omp_nest_lock_arg (lock)); | |
118 | #ifndef OMP_NEST_LOCK_DIRECT | |
119 | free (omp_nest_lock_arg (lock)); | |
120 | omp_nest_lock_arg (lock) = NULL; | |
121 | #endif | |
122 | } | |
123 | ||
124 | void | |
125 | gomp_set_lock__30 (omp_lock_arg_t lock) | |
126 | { | |
127 | gomp_set_lock_30 (omp_lock_arg (lock)); | |
128 | } | |
129 | ||
130 | void | |
131 | gomp_set_nest_lock__30 (omp_nest_lock_arg_t lock) | |
132 | { | |
133 | gomp_set_nest_lock_30 (omp_nest_lock_arg (lock)); | |
134 | } | |
135 | ||
136 | void | |
137 | gomp_unset_lock__30 (omp_lock_arg_t lock) | |
138 | { | |
139 | gomp_unset_lock_30 (omp_lock_arg (lock)); | |
140 | } | |
141 | ||
142 | void | |
143 | gomp_unset_nest_lock__30 (omp_nest_lock_arg_t lock) | |
144 | { | |
145 | gomp_unset_nest_lock_30 (omp_nest_lock_arg (lock)); | |
146 | } | |
147 | ||
148 | int32_t | |
149 | gomp_test_lock__30 (omp_lock_arg_t lock) | |
150 | { | |
151 | return gomp_test_lock_30 (omp_lock_arg (lock)); | |
152 | } | |
153 | ||
154 | int32_t | |
155 | gomp_test_nest_lock__30 (omp_nest_lock_arg_t lock) | |
156 | { | |
157 | return gomp_test_nest_lock_30 (omp_nest_lock_arg (lock)); | |
158 | } | |
159 | ||
160 | #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING | |
161 | void | |
162 | gomp_init_lock__25 (omp_lock_25_arg_t lock) | |
163 | { | |
164 | #ifndef OMP_LOCK_25_DIRECT | |
165 | omp_lock_25_arg (lock) = malloc (sizeof (omp_lock_25_t)); | |
166 | #endif | |
167 | gomp_init_lock_25 (omp_lock_25_arg (lock)); | |
168 | } | |
169 | ||
170 | void | |
171 | gomp_init_nest_lock__25 (omp_nest_lock_25_arg_t lock) | |
172 | { | |
173 | #ifndef OMP_NEST_LOCK_25_DIRECT | |
174 | omp_nest_lock_25_arg (lock) = malloc (sizeof (omp_nest_lock_25_t)); | |
175 | #endif | |
176 | gomp_init_nest_lock_25 (omp_nest_lock_25_arg (lock)); | |
177 | } | |
178 | ||
179 | void | |
180 | gomp_destroy_lock__25 (omp_lock_25_arg_t lock) | |
181 | { | |
182 | gomp_destroy_lock_25 (omp_lock_25_arg (lock)); | |
183 | #ifndef OMP_LOCK_25_DIRECT | |
184 | free (omp_lock_25_arg (lock)); | |
185 | omp_lock_25_arg (lock) = NULL; | |
186 | #endif | |
187 | } | |
188 | ||
189 | void | |
190 | gomp_destroy_nest_lock__25 (omp_nest_lock_25_arg_t lock) | |
191 | { | |
192 | gomp_destroy_nest_lock_25 (omp_nest_lock_25_arg (lock)); | |
193 | #ifndef OMP_NEST_LOCK_25_DIRECT | |
194 | free (omp_nest_lock_25_arg (lock)); | |
195 | omp_nest_lock_25_arg (lock) = NULL; | |
196 | #endif | |
197 | } | |
198 | ||
199 | void | |
200 | gomp_set_lock__25 (omp_lock_25_arg_t lock) | |
201 | { | |
202 | gomp_set_lock_25 (omp_lock_25_arg (lock)); | |
203 | } | |
204 | ||
205 | void | |
206 | gomp_set_nest_lock__25 (omp_nest_lock_25_arg_t lock) | |
207 | { | |
208 | gomp_set_nest_lock_25 (omp_nest_lock_25_arg (lock)); | |
209 | } | |
210 | ||
211 | void | |
212 | gomp_unset_lock__25 (omp_lock_25_arg_t lock) | |
213 | { | |
214 | gomp_unset_lock_25 (omp_lock_25_arg (lock)); | |
215 | } | |
216 | ||
217 | void | |
218 | gomp_unset_nest_lock__25 (omp_nest_lock_25_arg_t lock) | |
219 | { | |
220 | gomp_unset_nest_lock_25 (omp_nest_lock_25_arg (lock)); | |
221 | } | |
222 | ||
223 | int32_t | |
224 | gomp_test_lock__25 (omp_lock_25_arg_t lock) | |
225 | { | |
226 | return gomp_test_lock_25 (omp_lock_25_arg (lock)); | |
227 | } | |
228 | ||
229 | int32_t | |
230 | gomp_test_nest_lock__25 (omp_nest_lock_25_arg_t lock) | |
231 | { | |
232 | return gomp_test_nest_lock_25 (omp_nest_lock_25_arg (lock)); | |
233 | } | |
234 | ||
235 | omp_lock_symver (omp_init_lock_) | |
236 | omp_lock_symver (omp_destroy_lock_) | |
237 | omp_lock_symver (omp_set_lock_) | |
238 | omp_lock_symver (omp_unset_lock_) | |
239 | omp_lock_symver (omp_test_lock_) | |
240 | omp_lock_symver (omp_init_nest_lock_) | |
241 | omp_lock_symver (omp_destroy_nest_lock_) | |
242 | omp_lock_symver (omp_set_nest_lock_) | |
243 | omp_lock_symver (omp_unset_nest_lock_) | |
244 | omp_lock_symver (omp_test_nest_lock_) | |
245 | #endif | |
246 | ||
247 | void | |
248 | omp_set_dynamic_ (const int32_t *set) | |
249 | { | |
250 | omp_set_dynamic (*set); | |
251 | } | |
252 | ||
253 | void | |
254 | omp_set_dynamic_8_ (const int64_t *set) | |
255 | { | |
256 | omp_set_dynamic (*set); | |
257 | } | |
258 | ||
259 | void | |
260 | omp_set_nested_ (const int32_t *set) | |
261 | { | |
262 | omp_set_nested (*set); | |
263 | } | |
264 | ||
265 | void | |
266 | omp_set_nested_8_ (const int64_t *set) | |
267 | { | |
268 | omp_set_nested (*set); | |
269 | } | |
270 | ||
271 | void | |
272 | omp_set_num_threads_ (const int32_t *set) | |
273 | { | |
274 | omp_set_num_threads (*set); | |
275 | } | |
276 | ||
277 | void | |
278 | omp_set_num_threads_8_ (const int64_t *set) | |
279 | { | |
280 | omp_set_num_threads (*set); | |
281 | } | |
282 | ||
283 | int32_t | |
284 | omp_get_dynamic_ (void) | |
285 | { | |
286 | return omp_get_dynamic (); | |
287 | } | |
288 | ||
289 | int32_t | |
290 | omp_get_nested_ (void) | |
291 | { | |
292 | return omp_get_nested (); | |
293 | } | |
294 | ||
295 | int32_t | |
296 | omp_in_parallel_ (void) | |
297 | { | |
298 | return omp_in_parallel (); | |
299 | } | |
300 | ||
301 | int32_t | |
302 | omp_get_max_threads_ (void) | |
303 | { | |
304 | return omp_get_max_threads (); | |
305 | } | |
306 | ||
307 | int32_t | |
308 | omp_get_num_procs_ (void) | |
309 | { | |
310 | return omp_get_num_procs (); | |
311 | } | |
312 | ||
313 | int32_t | |
314 | omp_get_num_threads_ (void) | |
315 | { | |
316 | return omp_get_num_threads (); | |
317 | } | |
318 | ||
319 | int32_t | |
320 | omp_get_thread_num_ (void) | |
321 | { | |
322 | return omp_get_thread_num (); | |
323 | } | |
324 | ||
325 | double | |
326 | omp_get_wtick_ (void) | |
327 | { | |
328 | return omp_get_wtick (); | |
329 | } | |
330 | ||
331 | double | |
332 | omp_get_wtime_ (void) | |
333 | { | |
334 | return omp_get_wtime (); | |
335 | } | |
336 | ||
337 | void | |
338 | omp_set_schedule_ (const int32_t *kind, const int32_t *modifier) | |
339 | { | |
340 | omp_set_schedule (*kind, *modifier); | |
341 | } | |
342 | ||
343 | void | |
344 | omp_set_schedule_8_ (const int32_t *kind, const int64_t *modifier) | |
345 | { | |
346 | omp_set_schedule (*kind, *modifier); | |
347 | } | |
348 | ||
349 | void | |
350 | omp_get_schedule_ (int32_t *kind, int32_t *modifier) | |
351 | { | |
352 | omp_sched_t k; | |
353 | int m; | |
354 | omp_get_schedule (&k, &m); | |
355 | *kind = k; | |
356 | *modifier = m; | |
357 | } | |
358 | ||
359 | void | |
360 | omp_get_schedule_8_ (int32_t *kind, int64_t *modifier) | |
361 | { | |
362 | omp_sched_t k; | |
363 | int m; | |
364 | omp_get_schedule (&k, &m); | |
365 | *kind = k; | |
366 | *modifier = m; | |
367 | } | |
368 | ||
369 | int32_t | |
370 | omp_get_thread_limit_ (void) | |
371 | { | |
372 | return omp_get_thread_limit (); | |
373 | } | |
374 | ||
375 | void | |
376 | omp_set_max_active_levels_ (const int32_t *levels) | |
377 | { | |
378 | omp_set_max_active_levels (*levels); | |
379 | } | |
380 | ||
381 | void | |
382 | omp_set_max_active_levels_8_ (const int64_t *levels) | |
383 | { | |
384 | omp_set_max_active_levels (*levels); | |
385 | } | |
386 | ||
387 | int32_t | |
388 | omp_get_max_active_levels_ (void) | |
389 | { | |
390 | return omp_get_max_active_levels (); | |
391 | } | |
392 | ||
393 | int32_t | |
394 | omp_get_level_ (void) | |
395 | { | |
396 | return omp_get_level (); | |
397 | } | |
398 | ||
399 | int32_t | |
400 | omp_get_ancestor_thread_num_ (const int32_t *level) | |
401 | { | |
402 | return omp_get_ancestor_thread_num (*level); | |
403 | } | |
404 | ||
405 | int32_t | |
406 | omp_get_ancestor_thread_num_8_ (const int64_t *level) | |
407 | { | |
408 | return omp_get_ancestor_thread_num (*level); | |
409 | } | |
410 | ||
411 | int32_t | |
412 | omp_get_team_size_ (const int32_t *level) | |
413 | { | |
414 | return omp_get_team_size (*level); | |
415 | } | |
416 | ||
417 | int32_t | |
418 | omp_get_team_size_8_ (const int64_t *level) | |
419 | { | |
420 | return omp_get_team_size (*level); | |
421 | } | |
422 | ||
423 | int32_t | |
424 | omp_get_active_level_ (void) | |
425 | { | |
426 | return omp_get_active_level (); | |
427 | } |