OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libgomp/] [fortran.c] - Blame information for rev 473

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 273 jeremybenn 
/* 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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.