1 /* Copyright (C) 2005-2023 Free Software Foundation, Inc.
2 Contributed by Jakub Jelinek <jakub@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 Fortran wrapper routines. */
27
28 #include "libgomp.h"
29 #include "libgomp_f.h"
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <string.h>
33 #include <limits.h>
34
35 #ifdef HAVE_ATTRIBUTE_ALIAS
36 /* Use internal aliases if possible. */
37 # ifndef LIBGOMP_GNU_SYMBOL_VERSIONING
38 ialias_redirect (omp_init_lock)
39 ialias_redirect (omp_init_nest_lock)
40 ialias_redirect (omp_destroy_lock)
41 ialias_redirect (omp_destroy_nest_lock)
42 ialias_redirect (omp_set_lock)
43 ialias_redirect (omp_set_nest_lock)
44 ialias_redirect (omp_unset_lock)
45 ialias_redirect (omp_unset_nest_lock)
46 ialias_redirect (omp_test_lock)
47 ialias_redirect (omp_test_nest_lock)
48 # endif
49 ialias_redirect (omp_set_dynamic)
50 ialias_redirect (omp_get_dynamic)
51 #pragma GCC diagnostic push
52 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
53 ialias_redirect (omp_set_nested)
54 ialias_redirect (omp_get_nested)
55 #pragma GCC diagnostic pop
56 ialias_redirect (omp_set_num_threads)
57 ialias_redirect (omp_in_parallel)
58 ialias_redirect (omp_get_max_threads)
59 ialias_redirect (omp_get_num_procs)
60 ialias_redirect (omp_get_num_threads)
61 ialias_redirect (omp_get_thread_num)
62 ialias_redirect (omp_get_wtick)
63 ialias_redirect (omp_get_wtime)
64 ialias_redirect (omp_set_schedule)
65 ialias_redirect (omp_get_schedule)
66 ialias_redirect (omp_get_thread_limit)
67 ialias_redirect (omp_set_max_active_levels)
68 ialias_redirect (omp_get_max_active_levels)
69 ialias_redirect (omp_get_supported_active_levels)
70 ialias_redirect (omp_set_num_teams)
71 ialias_redirect (omp_get_max_teams)
72 ialias_redirect (omp_set_teams_thread_limit)
73 ialias_redirect (omp_get_teams_thread_limit)
74 ialias_redirect (omp_get_level)
75 ialias_redirect (omp_get_ancestor_thread_num)
76 ialias_redirect (omp_get_team_size)
77 ialias_redirect (omp_get_active_level)
78 ialias_redirect (omp_in_final)
79 ialias_redirect (omp_in_explicit_task)
80 ialias_redirect (omp_get_cancellation)
81 ialias_redirect (omp_get_proc_bind)
82 ialias_redirect (omp_get_num_places)
83 ialias_redirect (omp_get_place_num_procs)
84 ialias_redirect (omp_get_place_proc_ids)
85 ialias_redirect (omp_get_place_num)
86 ialias_redirect (omp_get_partition_num_places)
87 ialias_redirect (omp_get_partition_place_nums)
88 ialias_redirect (omp_set_default_device)
89 ialias_redirect (omp_get_default_device)
90 ialias_redirect (omp_get_num_devices)
91 ialias_redirect (omp_get_device_num)
92 ialias_redirect (omp_get_num_teams)
93 ialias_redirect (omp_get_team_num)
94 ialias_redirect (omp_is_initial_device)
95 ialias_redirect (omp_get_initial_device)
96 ialias_redirect (omp_get_max_task_priority)
97 ialias_redirect (omp_pause_resource)
98 ialias_redirect (omp_pause_resource_all)
99 ialias_redirect (omp_init_allocator)
100 ialias_redirect (omp_destroy_allocator)
101 ialias_redirect (omp_set_default_allocator)
102 ialias_redirect (omp_get_default_allocator)
103 ialias_redirect (omp_display_env)
104 ialias_redirect (omp_fulfill_event)
105 #endif
106
107 #ifndef LIBGOMP_GNU_SYMBOL_VERSIONING
108 # define gomp_init_lock__30 omp_init_lock_
109 # define gomp_destroy_lock__30 omp_destroy_lock_
110 # define gomp_set_lock__30 omp_set_lock_
111 # define gomp_unset_lock__30 omp_unset_lock_
112 # define gomp_test_lock__30 omp_test_lock_
113 # define gomp_init_nest_lock__30 omp_init_nest_lock_
114 # define gomp_destroy_nest_lock__30 omp_destroy_nest_lock_
115 # define gomp_set_nest_lock__30 omp_set_nest_lock_
116 # define gomp_unset_nest_lock__30 omp_unset_nest_lock_
117 # define gomp_test_nest_lock__30 omp_test_nest_lock_
118 #endif
119
120 void
121 gomp_init_lock__30 (omp_lock_arg_t lock)
122 {
123 #ifndef OMP_LOCK_DIRECT
124 omp_lock_arg (lock) = malloc (sizeof (omp_lock_t));
125 #endif
126 gomp_init_lock_30 (omp_lock_arg (lock));
127 }
128
129 void
130 gomp_init_nest_lock__30 (omp_nest_lock_arg_t lock)
131 {
132 #ifndef OMP_NEST_LOCK_DIRECT
133 omp_nest_lock_arg (lock) = malloc (sizeof (omp_nest_lock_t));
134 #endif
135 gomp_init_nest_lock_30 (omp_nest_lock_arg (lock));
136 }
137
138 void
139 gomp_destroy_lock__30 (omp_lock_arg_t lock)
140 {
141 gomp_destroy_lock_30 (omp_lock_arg (lock));
142 #ifndef OMP_LOCK_DIRECT
143 free (omp_lock_arg (lock));
144 omp_lock_arg (lock) = NULL;
145 #endif
146 }
147
148 void
149 gomp_destroy_nest_lock__30 (omp_nest_lock_arg_t lock)
150 {
151 gomp_destroy_nest_lock_30 (omp_nest_lock_arg (lock));
152 #ifndef OMP_NEST_LOCK_DIRECT
153 free (omp_nest_lock_arg (lock));
154 omp_nest_lock_arg (lock) = NULL;
155 #endif
156 }
157
158 void
159 gomp_set_lock__30 (omp_lock_arg_t lock)
160 {
161 gomp_set_lock_30 (omp_lock_arg (lock));
162 }
163
164 void
165 gomp_set_nest_lock__30 (omp_nest_lock_arg_t lock)
166 {
167 gomp_set_nest_lock_30 (omp_nest_lock_arg (lock));
168 }
169
170 void
171 gomp_unset_lock__30 (omp_lock_arg_t lock)
172 {
173 gomp_unset_lock_30 (omp_lock_arg (lock));
174 }
175
176 void
177 gomp_unset_nest_lock__30 (omp_nest_lock_arg_t lock)
178 {
179 gomp_unset_nest_lock_30 (omp_nest_lock_arg (lock));
180 }
181
182 int32_t
183 gomp_test_lock__30 (omp_lock_arg_t lock)
184 {
185 return gomp_test_lock_30 (omp_lock_arg (lock));
186 }
187
188 int32_t
189 gomp_test_nest_lock__30 (omp_nest_lock_arg_t lock)
190 {
191 return gomp_test_nest_lock_30 (omp_nest_lock_arg (lock));
192 }
193
194 #ifdef LIBGOMP_GNU_SYMBOL_VERSIONING
195 void
196 gomp_init_lock__25 (omp_lock_25_arg_t lock)
197 {
198 #ifndef OMP_LOCK_25_DIRECT
199 omp_lock_25_arg (lock) = malloc (sizeof (omp_lock_25_t));
200 #endif
201 gomp_init_lock_25 (omp_lock_25_arg (lock));
202 }
203
204 void
205 gomp_init_nest_lock__25 (omp_nest_lock_25_arg_t lock)
206 {
207 #ifndef OMP_NEST_LOCK_25_DIRECT
208 omp_nest_lock_25_arg (lock) = malloc (sizeof (omp_nest_lock_25_t));
209 #endif
210 gomp_init_nest_lock_25 (omp_nest_lock_25_arg (lock));
211 }
212
213 void
214 gomp_destroy_lock__25 (omp_lock_25_arg_t lock)
215 {
216 gomp_destroy_lock_25 (omp_lock_25_arg (lock));
217 #ifndef OMP_LOCK_25_DIRECT
218 free (omp_lock_25_arg (lock));
219 omp_lock_25_arg (lock) = NULL;
220 #endif
221 }
222
223 void
224 gomp_destroy_nest_lock__25 (omp_nest_lock_25_arg_t lock)
225 {
226 gomp_destroy_nest_lock_25 (omp_nest_lock_25_arg (lock));
227 #ifndef OMP_NEST_LOCK_25_DIRECT
228 free (omp_nest_lock_25_arg (lock));
229 omp_nest_lock_25_arg (lock) = NULL;
230 #endif
231 }
232
233 void
234 gomp_set_lock__25 (omp_lock_25_arg_t lock)
235 {
236 gomp_set_lock_25 (omp_lock_25_arg (lock));
237 }
238
239 void
240 gomp_set_nest_lock__25 (omp_nest_lock_25_arg_t lock)
241 {
242 gomp_set_nest_lock_25 (omp_nest_lock_25_arg (lock));
243 }
244
245 void
246 gomp_unset_lock__25 (omp_lock_25_arg_t lock)
247 {
248 gomp_unset_lock_25 (omp_lock_25_arg (lock));
249 }
250
251 void
252 gomp_unset_nest_lock__25 (omp_nest_lock_25_arg_t lock)
253 {
254 gomp_unset_nest_lock_25 (omp_nest_lock_25_arg (lock));
255 }
256
257 int32_t
258 gomp_test_lock__25 (omp_lock_25_arg_t lock)
259 {
260 return gomp_test_lock_25 (omp_lock_25_arg (lock));
261 }
262
263 int32_t
264 gomp_test_nest_lock__25 (omp_nest_lock_25_arg_t lock)
265 {
266 return gomp_test_nest_lock_25 (omp_nest_lock_25_arg (lock));
267 }
268
269 omp_lock_symver (omp_init_lock_)
270 omp_lock_symver (omp_destroy_lock_)
271 omp_lock_symver (omp_set_lock_)
272 omp_lock_symver (omp_unset_lock_)
273 omp_lock_symver (omp_test_lock_)
274 omp_lock_symver (omp_init_nest_lock_)
275 omp_lock_symver (omp_destroy_nest_lock_)
276 omp_lock_symver (omp_set_nest_lock_)
277 omp_lock_symver (omp_unset_nest_lock_)
278 omp_lock_symver (omp_test_nest_lock_)
279 #endif
280
281 #define TO_INT(x) ((x) > INT_MIN ? (x) < INT_MAX ? (x) : INT_MAX : INT_MIN)
282
283 void
284 omp_set_dynamic_ (const int32_t *set)
285 {
286 omp_set_dynamic (*set);
287 }
288
289 void
290 omp_set_dynamic_8_ (const int64_t *set)
291 {
292 omp_set_dynamic (!!*set);
293 }
294
295 #pragma GCC diagnostic push
296 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
297 void
298 omp_set_nested_ (const int32_t *set)
299 {
300 omp_set_nested (*set);
301 }
302
303 void
304 omp_set_nested_8_ (const int64_t *set)
305 {
306 omp_set_nested (!!*set);
307 }
308 #pragma GCC diagnostic pop
309
310 void
311 omp_set_num_threads_ (const int32_t *set)
312 {
313 omp_set_num_threads (*set);
314 }
315
316 void
317 omp_set_num_threads_8_ (const int64_t *set)
318 {
319 omp_set_num_threads (TO_INT (*set));
320 }
321
322 int32_t
323 omp_get_dynamic_ (void)
324 {
325 return omp_get_dynamic ();
326 }
327
328 #pragma GCC diagnostic push
329 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
330 int32_t
331 omp_get_nested_ (void)
332 {
333 return omp_get_nested ();
334 }
335 #pragma GCC diagnostic pop
336
337 int32_t
338 omp_in_parallel_ (void)
339 {
340 return omp_in_parallel ();
341 }
342
343 int32_t
344 omp_get_max_threads_ (void)
345 {
346 return omp_get_max_threads ();
347 }
348
349 int32_t
350 omp_get_num_procs_ (void)
351 {
352 return omp_get_num_procs ();
353 }
354
355 int32_t
356 omp_get_num_threads_ (void)
357 {
358 return omp_get_num_threads ();
359 }
360
361 int32_t
362 omp_get_thread_num_ (void)
363 {
364 return omp_get_thread_num ();
365 }
366
367 double
368 omp_get_wtick_ (void)
369 {
370 return omp_get_wtick ();
371 }
372
373 double
374 omp_get_wtime_ (void)
375 {
376 return omp_get_wtime ();
377 }
378
379 void
380 omp_set_schedule_ (const int32_t *kind, const int32_t *chunk_size)
381 {
382 omp_set_schedule (*kind, *chunk_size);
383 }
384
385 void
386 omp_set_schedule_8_ (const int32_t *kind, const int64_t *chunk_size)
387 {
388 omp_set_schedule (*kind, TO_INT (*chunk_size));
389 }
390
391 void
392 omp_get_schedule_ (int32_t *kind, int32_t *chunk_size)
393 {
394 omp_sched_t k;
395 int cs;
396 omp_get_schedule (&k, &cs);
397 /* For now mask off GFS_MONOTONIC, because OpenMP 4.5 code will not
398 expect to see it. */
399 *kind = k & ~GFS_MONOTONIC;
400 *chunk_size = cs;
401 }
402
403 void
404 omp_get_schedule_8_ (int32_t *kind, int64_t *chunk_size)
405 {
406 omp_sched_t k;
407 int cs;
408 omp_get_schedule (&k, &cs);
409 /* See above. */
410 *kind = k & ~GFS_MONOTONIC;
411 *chunk_size = cs;
412 }
413
414 int32_t
415 omp_get_thread_limit_ (void)
416 {
417 return omp_get_thread_limit ();
418 }
419
420 void
421 omp_set_max_active_levels_ (const int32_t *levels)
422 {
423 omp_set_max_active_levels (*levels);
424 }
425
426 void
427 omp_set_max_active_levels_8_ (const int64_t *levels)
428 {
429 omp_set_max_active_levels (TO_INT (*levels));
430 }
431
432 int32_t
433 omp_get_max_active_levels_ (void)
434 {
435 return omp_get_max_active_levels ();
436 }
437
438 int32_t
439 omp_get_supported_active_levels_ (void)
440 {
441 return omp_get_supported_active_levels ();
442 }
443
444 int32_t
445 omp_get_level_ (void)
446 {
447 return omp_get_level ();
448 }
449
450 int32_t
451 omp_get_ancestor_thread_num_ (const int32_t *level)
452 {
453 return omp_get_ancestor_thread_num (*level);
454 }
455
456 int32_t
457 omp_get_ancestor_thread_num_8_ (const int64_t *level)
458 {
459 return omp_get_ancestor_thread_num (TO_INT (*level));
460 }
461
462 int32_t
463 omp_get_team_size_ (const int32_t *level)
464 {
465 return omp_get_team_size (*level);
466 }
467
468 int32_t
469 omp_get_team_size_8_ (const int64_t *level)
470 {
471 return omp_get_team_size (TO_INT (*level));
472 }
473
474 int32_t
475 omp_get_active_level_ (void)
476 {
477 return omp_get_active_level ();
478 }
479
480 int32_t
481 omp_in_final_ (void)
482 {
483 return omp_in_final ();
484 }
485
486 int32_t
487 omp_in_explicit_task_ (void)
488 {
489 return omp_in_explicit_task ();
490 }
491
492 void
493 omp_set_num_teams_ (const int32_t *num_teams)
494 {
495 omp_set_num_teams (*num_teams);
496 }
497
498 void
499 omp_set_num_teams_8_ (const int64_t *num_teams)
500 {
501 omp_set_num_teams (TO_INT (*num_teams));
502 }
503
504 int32_t
505 omp_get_max_teams_ (void)
506 {
507 return omp_get_max_teams ();
508 }
509
510 void
511 omp_set_teams_thread_limit_ (const int32_t *thread_limit)
512 {
513 omp_set_teams_thread_limit (*thread_limit);
514 }
515
516 void
517 omp_set_teams_thread_limit_8_ (const int64_t *thread_limit)
518 {
519 omp_set_teams_thread_limit (TO_INT (*thread_limit));
520 }
521
522 int32_t
523 omp_get_teams_thread_limit_ (void)
524 {
525 return omp_get_teams_thread_limit ();
526 }
527
528 int32_t
529 omp_get_cancellation_ (void)
530 {
531 return omp_get_cancellation ();
532 }
533
534 int32_t
535 omp_get_proc_bind_ (void)
536 {
537 return omp_get_proc_bind ();
538 }
539
540 int32_t
541 omp_get_num_places_ (void)
542 {
543 return omp_get_num_places ();
544 }
545
546 int32_t
547 omp_get_place_num_procs_ (const int32_t *place_num)
548 {
549 return omp_get_place_num_procs (*place_num);
550 }
551
552 int32_t
553 omp_get_place_num_procs_8_ (const int64_t *place_num)
554 {
555 return omp_get_place_num_procs (TO_INT (*place_num));
556 }
557
558 void
559 omp_get_place_proc_ids_ (const int32_t *place_num, int32_t *ids)
560 {
561 omp_get_place_proc_ids (*place_num, (int *) ids);
562 }
563
564 void
565 omp_get_place_proc_ids_8_ (const int64_t *place_num, int64_t *ids)
566 {
567 gomp_get_place_proc_ids_8 (TO_INT (*place_num), ids);
568 }
569
570 int32_t
571 omp_get_place_num_ (void)
572 {
573 return omp_get_place_num ();
574 }
575
576 int32_t
577 omp_get_partition_num_places_ (void)
578 {
579 return omp_get_partition_num_places ();
580 }
581
582 void
583 omp_get_partition_place_nums_ (int32_t *place_nums)
584 {
585 omp_get_partition_place_nums ((int *) place_nums);
586 }
587
588 void
589 omp_get_partition_place_nums_8_ (int64_t *place_nums)
590 {
591 if (gomp_places_list == NULL)
592 return;
593
594 struct gomp_thread *thr = gomp_thread ();
595 if (thr->place == 0)
596 gomp_init_affinity ();
597
598 unsigned int i;
599 for (i = 0; i < thr->ts.place_partition_len; i++)
600 *place_nums++ = (int64_t) thr->ts.place_partition_off + i;
601 }
602
603 void
604 omp_set_default_device_ (const int32_t *device_num)
605 {
606 return omp_set_default_device (*device_num);
607 }
608
609 void
610 omp_set_default_device_8_ (const int64_t *device_num)
611 {
612 return omp_set_default_device (TO_INT (*device_num));
613 }
614
615 int32_t
616 omp_get_default_device_ (void)
617 {
618 return omp_get_default_device ();
619 }
620
621 int32_t
622 omp_get_num_devices_ (void)
623 {
624 return omp_get_num_devices ();
625 }
626
627 int32_t
628 omp_get_num_teams_ (void)
629 {
630 return omp_get_num_teams ();
631 }
632
633 int32_t
634 omp_get_team_num_ (void)
635 {
636 return omp_get_team_num ();
637 }
638
639 int32_t
640 omp_is_initial_device_ (void)
641 {
642 return omp_is_initial_device ();
643 }
644
645 int32_t
646 omp_get_initial_device_ (void)
647 {
648 return omp_get_initial_device ();
649 }
650
651 int32_t
652 omp_get_device_num_ (void)
653 {
654 return omp_get_device_num ();
655 }
656
657 int32_t
658 omp_get_max_task_priority_ (void)
659 {
660 return omp_get_max_task_priority ();
661 }
662
663 void
664 omp_fulfill_event_ (intptr_t event)
665 {
666 omp_fulfill_event ((omp_event_handle_t) event);
667 }
668
669 void
670 omp_set_affinity_format_ (const char *format, size_t format_len)
671 {
672 gomp_set_affinity_format (format, format_len);
673 }
674
675 int32_t
676 omp_get_affinity_format_ (char *buffer, size_t buffer_len)
677 {
678 size_t len = strlen (gomp_affinity_format_var);
679 if (buffer_len)
680 {
681 if (len < buffer_len)
682 {
683 memcpy (buffer, gomp_affinity_format_var, len);
684 memset (buffer + len, ' ', buffer_len - len);
685 }
686 else
687 memcpy (buffer, gomp_affinity_format_var, buffer_len);
688 }
689 return len;
690 }
691
692 void
693 omp_display_affinity_ (const char *format, size_t format_len)
694 {
695 char *fmt = NULL, fmt_buf[256];
696 char buf[512];
697 if (format_len)
698 {
699 fmt = format_len < 256 ? fmt_buf : gomp_malloc (format_len + 1);
700 memcpy (fmt, format, format_len);
701 fmt[format_len] = '\0';
702 }
703 struct gomp_thread *thr = gomp_thread ();
704 size_t ret
705 = gomp_display_affinity (buf, sizeof buf,
706 format_len ? fmt : gomp_affinity_format_var,
707 gomp_thread_self (), &thr->ts, thr->place);
708 if (ret < sizeof buf)
709 {
710 buf[ret] = '\n';
711 gomp_print_string (buf, ret + 1);
712 }
713 else
714 {
715 char *b = gomp_malloc (ret + 1);
716 gomp_display_affinity (buf, sizeof buf,
717 format_len ? fmt : gomp_affinity_format_var,
718 gomp_thread_self (), &thr->ts, thr->place);
719 b[ret] = '\n';
720 gomp_print_string (b, ret + 1);
721 free (b);
722 }
723 if (fmt && fmt != fmt_buf)
724 free (fmt);
725 }
726
727 int32_t
728 omp_capture_affinity_ (char *buffer, const char *format,
729 size_t buffer_len, size_t format_len)
730 {
731 char *fmt = NULL, fmt_buf[256];
732 if (format_len)
733 {
734 fmt = format_len < 256 ? fmt_buf : gomp_malloc (format_len + 1);
735 memcpy (fmt, format, format_len);
736 fmt[format_len] = '\0';
737 }
738 struct gomp_thread *thr = gomp_thread ();
739 size_t ret
740 = gomp_display_affinity (buffer, buffer_len,
741 format_len ? fmt : gomp_affinity_format_var,
742 gomp_thread_self (), &thr->ts, thr->place);
743 if (fmt && fmt != fmt_buf)
744 free (fmt);
745 if (ret < buffer_len)
746 memset (buffer + ret, ' ', buffer_len - ret);
747 return ret;
748 }
749
750 int32_t
751 omp_pause_resource_ (const int32_t *kind, const int32_t *device_num)
752 {
753 return omp_pause_resource (*kind, *device_num);
754 }
755
756 int32_t
757 omp_pause_resource_all_ (const int32_t *kind)
758 {
759 return omp_pause_resource_all (*kind);
760 }
761
762 intptr_t
763 omp_init_allocator_ (const intptr_t *memspace, const int32_t *ntraits,
764 const omp_alloctrait_t *traits)
765 {
766 return (intptr_t) omp_init_allocator ((omp_memspace_handle_t) *memspace,
767 (int) *ntraits, traits);
768 }
769
770 intptr_t
771 omp_init_allocator_8_ (const intptr_t *memspace, const int64_t *ntraits,
772 const omp_alloctrait_t *traits)
773 {
774 return (intptr_t) omp_init_allocator ((omp_memspace_handle_t) *memspace,
775 (int) *ntraits, traits);
776 }
777
778 void
779 omp_destroy_allocator_ (const intptr_t *allocator)
780 {
781 omp_destroy_allocator ((omp_allocator_handle_t) *allocator);
782 }
783
784 void
785 omp_set_default_allocator_ (const intptr_t *allocator)
786 {
787 omp_set_default_allocator ((omp_allocator_handle_t) *allocator);
788 }
789
790 intptr_t
791 omp_get_default_allocator_ ()
792 {
793 return (intptr_t) omp_get_default_allocator ();
794 }
795
796 #ifndef LIBGOMP_OFFLOADED_ONLY
797
798 void
799 omp_display_env_ (const int32_t *verbose)
800 {
801 omp_display_env (*verbose);
802 }
803
804 void
805 omp_display_env_8_ (const int64_t *verbose)
806 {
807 omp_display_env (!!*verbose);
808 }
809
810 #endif /* LIBGOMP_OFFLOADED_ONLY */