Mercurial > hg > CbC > CbC_gcc

comparison libgomp/fortran.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 04ced10e8804
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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 }