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