1 /** 2 * D header file for POSIX. 3 * 4 * Copyright: Copyright Sean Kelly 2005 - 2009. 5 * License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). 6 * Authors: Sean Kelly, Alex Rønne Petersen 7 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition 8 */ 9 10 /* Copyright Sean Kelly 2005 - 2009. 11 * Distributed under the Boost Software License, Version 1.0. 12 * (See accompanying file LICENSE or copy at 13 * http://www.boost.org/LICENSE_1_0.txt) 14 */ 15 module core.sys.posix.sys.mman; 16 17 import core.sys.posix.config; 18 public import core.sys.posix.sys.types; // for off_t, mode_t 19 20 version (OSX) 21 version = Darwin; 22 else version (iOS) 23 version = Darwin; 24 else version (TVOS) 25 version = Darwin; 26 else version (WatchOS) 27 version = Darwin; 28 29 version (ARM) version = ARM_Any; 30 version (AArch64) version = ARM_Any; 31 version (HPPA) version = HPPA_Any; 32 version (HPPA64) version = HPPA_Any; 33 version (MIPS32) version = MIPS_Any; 34 version (MIPS64) version = MIPS_Any; 35 version (PPC) version = PPC_Any; 36 version (PPC64) version = PPC_Any; 37 version (RISCV32) version = RISCV_Any; 38 version (RISCV64) version = RISCV_Any; 39 version (S390) version = IBMZ_Any; 40 version (SPARC) version = SPARC_Any; 41 version (SPARC64) version = SPARC_Any; 42 version (SystemZ) version = IBMZ_Any; 43 version (X86) version = X86_Any; 44 version (X86_64) version = X86_Any; 45 46 version (Posix): 47 extern (C) nothrow @nogc: 48 49 // 50 // Advisory Information (ADV) 51 // 52 /* 53 int posix_madvise(void*, size_t, int); 54 */ 55 56 version (CRuntime_Glibc) 57 { 58 static if (_XOPEN_SOURCE >= 600) 59 { 60 int posix_madvise(void *__addr, size_t __len, int __advice); 61 } 62 } 63 else version (Darwin) 64 { 65 int posix_madvise(void *addr, size_t len, int advice); 66 } 67 else version (FreeBSD) 68 { 69 int posix_madvise(void *addr, size_t len, int advice); 70 } 71 else version (NetBSD) 72 { 73 int posix_madvise(void *addr, size_t len, int advice); 74 } 75 else version (OpenBSD) 76 { 77 int posix_madvise(void *addr, size_t len, int advice); 78 } 79 else version (DragonFlyBSD) 80 { 81 int posix_madvise(void *addr, size_t len, int advice); 82 } 83 else version (Solaris) 84 { 85 } 86 else version (CRuntime_Bionic) 87 { 88 } 89 else version (CRuntime_Musl) 90 { 91 int posix_madvise(void *, size_t, int); 92 } 93 else version (CRuntime_UClibc) 94 { 95 int posix_madvise(void *__addr, size_t __len, int __advice); 96 } 97 else 98 { 99 static assert(false, "Unsupported platform"); 100 } 101 102 103 // 104 // Advisory Information and either Memory Mapped Files or Shared Memory Objects (MC1) 105 // 106 /* 107 POSIX_MADV_NORMAL 108 POSIX_MADV_SEQUENTIAL 109 POSIX_MADV_RANDOM 110 POSIX_MADV_WILLNEED 111 POSIX_MADV_DONTNEED 112 */ 113 114 version (linux) 115 { 116 version (Alpha) 117 private enum __POSIX_MADV_DONTNEED = 6; 118 else 119 private enum __POSIX_MADV_DONTNEED = 4; 120 121 enum 122 { 123 POSIX_MADV_NORMAL = 0, 124 POSIX_MADV_RANDOM = 1, 125 POSIX_MADV_SEQUENTIAL = 2, 126 POSIX_MADV_WILLNEED = 3, 127 POSIX_MADV_DONTNEED = __POSIX_MADV_DONTNEED, 128 } 129 } 130 else version (Darwin) 131 { 132 enum POSIX_MADV_NORMAL = 0; 133 enum POSIX_MADV_RANDOM = 1; 134 enum POSIX_MADV_SEQUENTIAL = 2; 135 enum POSIX_MADV_WILLNEED = 3; 136 enum POSIX_MADV_DONTNEED = 4; 137 } 138 else version (FreeBSD) 139 { 140 enum POSIX_MADV_NORMAL = 0; 141 enum POSIX_MADV_RANDOM = 1; 142 enum POSIX_MADV_SEQUENTIAL = 2; 143 enum POSIX_MADV_WILLNEED = 3; 144 enum POSIX_MADV_DONTNEED = 4; 145 } 146 else version (NetBSD) 147 { 148 enum POSIX_MADV_NORMAL = 0; 149 enum POSIX_MADV_RANDOM = 1; 150 enum POSIX_MADV_SEQUENTIAL = 2; 151 enum POSIX_MADV_WILLNEED = 3; 152 enum POSIX_MADV_DONTNEED = 4; 153 } 154 else version (OpenBSD) 155 { 156 enum POSIX_MADV_NORMAL = 0; 157 enum POSIX_MADV_RANDOM = 1; 158 enum POSIX_MADV_SEQUENTIAL = 2; 159 enum POSIX_MADV_WILLNEED = 3; 160 enum POSIX_MADV_DONTNEED = 4; 161 } 162 else version (DragonFlyBSD) 163 { 164 enum POSIX_MADV_NORMAL = 0; 165 enum POSIX_MADV_RANDOM = 1; 166 enum POSIX_MADV_SEQUENTIAL = 2; 167 enum POSIX_MADV_WILLNEED = 3; 168 enum POSIX_MADV_DONTNEED = 4; 169 } 170 else version (Solaris) 171 { 172 } 173 else 174 { 175 static assert(false, "Unsupported platform"); 176 } 177 178 // 179 // Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2) 180 // 181 /* 182 PROT_READ 183 PROT_WRITE 184 PROT_EXEC 185 PROT_NONE 186 */ 187 188 version (linux) 189 { 190 enum PROT_NONE = 0x0; 191 enum PROT_READ = 0x1; 192 enum PROT_WRITE = 0x2; 193 enum PROT_EXEC = 0x4; 194 } 195 else version (Darwin) 196 { 197 enum PROT_NONE = 0x00; 198 enum PROT_READ = 0x01; 199 enum PROT_WRITE = 0x02; 200 enum PROT_EXEC = 0x04; 201 } 202 else version (FreeBSD) 203 { 204 enum PROT_NONE = 0x00; 205 enum PROT_READ = 0x01; 206 enum PROT_WRITE = 0x02; 207 enum PROT_EXEC = 0x04; 208 } 209 else version (NetBSD) 210 { 211 enum PROT_NONE = 0x00; 212 enum PROT_READ = 0x01; 213 enum PROT_WRITE = 0x02; 214 enum PROT_EXEC = 0x04; 215 } 216 else version (OpenBSD) 217 { 218 enum PROT_NONE = 0x00; 219 enum PROT_READ = 0x01; 220 enum PROT_WRITE = 0x02; 221 enum PROT_EXEC = 0x04; 222 } 223 else version (DragonFlyBSD) 224 { 225 enum PROT_NONE = 0x00; 226 enum PROT_READ = 0x01; 227 enum PROT_WRITE = 0x02; 228 enum PROT_EXEC = 0x04; 229 } 230 else version (Solaris) 231 { 232 enum PROT_NONE = 0x00; 233 enum PROT_READ = 0x01; 234 enum PROT_WRITE = 0x02; 235 enum PROT_EXEC = 0x04; 236 } 237 else 238 { 239 static assert(false, "Unsupported platform"); 240 } 241 242 // 243 // Memory Mapped Files, Shared Memory Objects, or Typed Memory Objects (MC3) 244 // 245 /* 246 void* mmap(void*, size_t, int, int, int, off_t); 247 int munmap(void*, size_t); 248 */ 249 250 version (CRuntime_Glibc) 251 { 252 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t); 253 static if (__USE_FILE_OFFSET64) 254 alias mmap = mmap64; 255 else 256 void* mmap(void*, size_t, int, int, int, off_t); 257 int munmap(void*, size_t); 258 } 259 else version (Darwin) 260 { 261 void* mmap(void*, size_t, int, int, int, off_t); 262 int munmap(void*, size_t); 263 } 264 else version (FreeBSD) 265 { 266 void* mmap(void*, size_t, int, int, int, off_t); 267 int munmap(void*, size_t); 268 } 269 else version (NetBSD) 270 { 271 void* mmap(void*, size_t, int, int, int, off_t); 272 int munmap(void*, size_t); 273 } 274 else version (OpenBSD) 275 { 276 void* mmap(void*, size_t, int, int, int, off_t); 277 int munmap(void*, size_t); 278 } 279 else version (DragonFlyBSD) 280 { 281 void* mmap(void*, size_t, int, int, int, off_t); 282 int munmap(void*, size_t); 283 } 284 else version (Solaris) 285 { 286 void* mmap(void*, size_t, int, int, int, off_t); 287 int munmap(void*, size_t); 288 } 289 else version (CRuntime_Bionic) 290 { 291 void* mmap(void*, size_t, int, int, int, off_t); 292 int munmap(void*, size_t); 293 } 294 else version (CRuntime_Musl) 295 { 296 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t); 297 static if (__USE_FILE_OFFSET64) 298 alias mmap = mmap64; 299 else 300 void* mmap(void*, size_t, int, int, int, off_t); 301 int munmap(void*, size_t); 302 } 303 else version (CRuntime_UClibc) 304 { 305 static if (__USE_LARGEFILE64) void* mmap64(void*, size_t, int, int, int, off_t); 306 static if (__USE_FILE_OFFSET64) 307 alias mmap = mmap64; 308 else 309 void* mmap(void*, size_t, int, int, int, off_t); 310 int munmap(void*, size_t); 311 } 312 else 313 { 314 static assert(false, "Unsupported platform"); 315 } 316 317 // 318 // Memory Mapped Files (MF) 319 // 320 /* 321 MAP_SHARED (MF|SHM) 322 MAP_PRIVATE (MF|SHM) 323 MAP_FIXED (MF|SHM) 324 MAP_FAILED (MF|SHM) 325 326 MS_ASYNC (MF|SIO) 327 MS_SYNC (MF|SIO) 328 MS_INVALIDATE (MF|SIO) 329 */ 330 331 version (linux) 332 { 333 enum MAP_SHARED = 0x01; 334 enum MAP_PRIVATE = 0x02; 335 enum MAP_FIXED = 0x10; 336 337 enum MAP_FAILED = cast(void*) -1; 338 339 version (MICROBLAZE) 340 private enum DEFAULTS = true; 341 else version (Alpha) 342 { 343 private enum DEFAULTS = false; 344 enum MAP_ANON = 0x10; 345 enum MS_ASYNC = 1; 346 enum MS_SYNC = 2; 347 enum MS_INVALIDATE = 4; 348 } 349 else version (SH) 350 private enum DEFAULTS = true; 351 else version (ARM_Any) 352 private enum DEFAULTS = true; 353 else version (IBMZ_Any) 354 private enum DEFAULTS = true; 355 else version (IA64) 356 private enum DEFAULTS = true; 357 else version (HPPA_Any) 358 { 359 private enum DEFAULTS = false; 360 enum MAP_ANON = 0x10; 361 enum MS_SYNC = 1; 362 enum MS_ASYNC = 2; 363 enum MS_INVALIDATE = 4; 364 } 365 else version (M68K) 366 private enum DEFAULTS = true; 367 else version (TILE) 368 private enum DEFAULTS = true; 369 else version (X86_Any) 370 private enum DEFAULTS = true; 371 else version (MIPS_Any) 372 { 373 private enum DEFAULTS = false; 374 enum MAP_ANON = 0x0800; 375 enum MS_ASYNC = 1; 376 enum MS_INVALIDATE = 2; 377 enum MS_SYNC = 4; 378 } 379 else version (RISCV_Any) 380 private enum DEFAULTS = true; 381 else version (SPARC_Any) 382 private enum DEFAULTS = true; 383 else version (PPC_Any) 384 private enum DEFAULTS = true; 385 else version (LoongArch64) 386 private enum DEFAULTS = true; 387 else 388 static assert(0, "unimplemented"); 389 390 static if (DEFAULTS) 391 { 392 enum MAP_ANON = 0x20; 393 enum MS_ASYNC = 1; 394 enum MS_INVALIDATE = 2; 395 enum MS_SYNC = 4; 396 } 397 } 398 else version (Darwin) 399 { 400 enum MAP_SHARED = 0x0001; 401 enum MAP_PRIVATE = 0x0002; 402 enum MAP_FIXED = 0x0010; 403 enum MAP_ANON = 0x1000; 404 405 enum MAP_FAILED = cast(void*)-1; 406 407 enum MS_ASYNC = 0x0001; 408 enum MS_INVALIDATE = 0x0002; 409 enum MS_SYNC = 0x0010; 410 } 411 else version (FreeBSD) 412 { 413 enum MAP_SHARED = 0x0001; 414 enum MAP_PRIVATE = 0x0002; 415 enum MAP_FIXED = 0x0010; 416 enum MAP_ANON = 0x1000; 417 418 enum MAP_FAILED = cast(void*)-1; 419 420 enum MS_SYNC = 0x0000; 421 enum MS_ASYNC = 0x0001; 422 enum MS_INVALIDATE = 0x0002; 423 } 424 else version (NetBSD) 425 { 426 enum MAP_SHARED = 0x0001; 427 enum MAP_PRIVATE = 0x0002; 428 enum MAP_FIXED = 0x0010; 429 enum MAP_ANON = 0x1000; 430 431 enum MAP_FAILED = cast(void*)-1; 432 433 enum MS_SYNC = 0x0004; 434 enum MS_ASYNC = 0x0001; 435 enum MS_INVALIDATE = 0x0002; 436 } 437 else version (OpenBSD) 438 { 439 enum MAP_SHARED = 0x0001; 440 enum MAP_PRIVATE = 0x0002; 441 enum MAP_FIXED = 0x0010; 442 enum MAP_ANON = 0x1000; 443 enum MAP_STACK = 0x4000; 444 445 enum MAP_FAILED = cast(void*)-1; 446 447 enum MS_SYNC = 0x0002; 448 enum MS_ASYNC = 0x0001; 449 enum MS_INVALIDATE = 0x0004; 450 } 451 else version (DragonFlyBSD) 452 { 453 enum MAP_SHARED = 0x0001; 454 enum MAP_PRIVATE = 0x0002; 455 enum MAP_FIXED = 0x0010; 456 enum MAP_ANON = 0x1000; 457 458 enum MAP_FAILED = cast(void*)-1; 459 460 enum MS_SYNC = 0x0000; 461 enum MS_ASYNC = 0x0001; 462 enum MS_INVALIDATE = 0x0002; 463 } 464 else version (Solaris) 465 { 466 enum MAP_SHARED = 0x0001; 467 enum MAP_PRIVATE = 0x0002; 468 enum MAP_FIXED = 0x0010; 469 enum MAP_ANON = 0x0100; 470 471 enum MAP_FAILED = cast(void*)-1; 472 473 enum MS_SYNC = 0x0004; 474 enum MS_ASYNC = 0x0001; 475 enum MS_INVALIDATE = 0x0002; 476 } 477 else 478 { 479 static assert(false, "Unsupported platform"); 480 } 481 482 /* 483 int msync(void*, size_t, int); (MF|SIO) 484 */ 485 486 version (CRuntime_Glibc) 487 { 488 int msync(void*, size_t, int); 489 } 490 else version (Darwin) 491 { 492 int msync(void*, size_t, int); 493 } 494 else version (FreeBSD) 495 { 496 int msync(void*, size_t, int); 497 } 498 else version (NetBSD) 499 { 500 int __msync13(void*, size_t, int); 501 alias msync = __msync13; 502 } 503 else version (OpenBSD) 504 { 505 int msync(void*, size_t, int); 506 } 507 else version (DragonFlyBSD) 508 { 509 int msync(void*, size_t, int); 510 } 511 else version (Solaris) 512 { 513 int msync(void*, size_t, int); 514 } 515 else version (CRuntime_Bionic) 516 { 517 int msync(const scope void*, size_t, int); 518 } 519 else version (CRuntime_Musl) 520 { 521 int msync(void*, size_t, int); 522 } 523 else version (CRuntime_UClibc) 524 { 525 int msync(void*, size_t, int); 526 } 527 else 528 { 529 static assert(false, "Unsupported platform"); 530 } 531 532 // 533 // Process Memory Locking (ML) 534 // 535 /* 536 MCL_CURRENT 537 MCL_FUTURE 538 */ 539 540 version (linux) 541 { 542 version (SPARC_Any) enum 543 { 544 MCL_CURRENT = 0x2000, 545 MCL_FUTURE = 0x4000, 546 } 547 else version (PPC_Any) enum 548 { 549 MCL_CURRENT = 0x2000, 550 MCL_FUTURE = 0x4000, 551 } 552 else version (Alpha) enum 553 { 554 MCL_CURRENT = 8192, 555 MCL_FUTURE = 16384, 556 } 557 else enum 558 { 559 MCL_CURRENT = 1, 560 MCL_FUTURE = 2, 561 } 562 } 563 else version (Darwin) 564 { 565 enum MCL_CURRENT = 0x0001; 566 enum MCL_FUTURE = 0x0002; 567 } 568 else version (FreeBSD) 569 { 570 enum MCL_CURRENT = 0x0001; 571 enum MCL_FUTURE = 0x0002; 572 } 573 else version (NetBSD) 574 { 575 enum MCL_CURRENT = 0x0001; 576 enum MCL_FUTURE = 0x0002; 577 } 578 else version (OpenBSD) 579 { 580 enum MCL_CURRENT = 0x0001; 581 enum MCL_FUTURE = 0x0002; 582 } 583 else version (DragonFlyBSD) 584 { 585 enum MCL_CURRENT = 0x0001; 586 enum MCL_FUTURE = 0x0002; 587 } 588 else version (Solaris) 589 { 590 enum MCL_CURRENT = 0x0001; 591 enum MCL_FUTURE = 0x0002; 592 } 593 else 594 { 595 static assert(false, "Unsupported platform"); 596 } 597 598 /* 599 int mlockall(int); 600 int munlockall(); 601 */ 602 603 version (CRuntime_Glibc) 604 { 605 int mlockall(int); 606 int munlockall(); 607 } 608 else version (Darwin) 609 { 610 int mlockall(int); 611 int munlockall(); 612 } 613 else version (FreeBSD) 614 { 615 int mlockall(int); 616 int munlockall(); 617 } 618 else version (NetBSD) 619 { 620 int mlockall(int); 621 int munlockall(); 622 } 623 else version (OpenBSD) 624 { 625 int mlockall(int); 626 int munlockall(); 627 } 628 else version (DragonFlyBSD) 629 { 630 int mlockall(int); 631 int munlockall(); 632 } 633 else version (Solaris) 634 { 635 int mlockall(int); 636 int munlockall(); 637 } 638 else version (CRuntime_Bionic) 639 { 640 int mlockall(int); 641 int munlockall(); 642 } 643 else version (CRuntime_Musl) 644 { 645 int mlockall(int); 646 int munlockall(); 647 } 648 else version (CRuntime_UClibc) 649 { 650 int mlockall(int); 651 int munlockall(); 652 } 653 else 654 { 655 static assert(false, "Unsupported platform"); 656 } 657 658 // 659 // Range Memory Locking (MLR) 660 // 661 /* 662 int mlock(const scope void*, size_t); 663 int munlock(const scope void*, size_t); 664 */ 665 666 version (CRuntime_Glibc) 667 { 668 int mlock(const scope void*, size_t); 669 int munlock(const scope void*, size_t); 670 } 671 else version (Darwin) 672 { 673 int mlock(const scope void*, size_t); 674 int munlock(const scope void*, size_t); 675 } 676 else version (FreeBSD) 677 { 678 int mlock(const scope void*, size_t); 679 int munlock(const scope void*, size_t); 680 } 681 else version (NetBSD) 682 { 683 int mlock(const scope void*, size_t); 684 int munlock(const scope void*, size_t); 685 } 686 else version (OpenBSD) 687 { 688 int mlock(const scope void*, size_t); 689 int munlock(const scope void*, size_t); 690 } 691 else version (DragonFlyBSD) 692 { 693 int mlock(const scope void*, size_t); 694 int munlock(const scope void*, size_t); 695 } 696 else version (Solaris) 697 { 698 int mlock(const scope void*, size_t); 699 int munlock(const scope void*, size_t); 700 } 701 else version (CRuntime_Bionic) 702 { 703 int mlock(const scope void*, size_t); 704 int munlock(const scope void*, size_t); 705 } 706 else version (CRuntime_Musl) 707 { 708 int mlock(const scope void*, size_t); 709 int munlock(const scope void*, size_t); 710 } 711 else version (CRuntime_UClibc) 712 { 713 int mlock(const scope void*, size_t); 714 int munlock(const scope void*, size_t); 715 } 716 else 717 { 718 static assert(false, "Unsupported platform"); 719 } 720 721 // 722 // Memory Protection (MPR) 723 // 724 /* 725 int mprotect(void*, size_t, int); 726 */ 727 728 version (CRuntime_Glibc) 729 { 730 int mprotect(void*, size_t, int); 731 } 732 else version (Darwin) 733 { 734 int mprotect(void*, size_t, int); 735 } 736 else version (FreeBSD) 737 { 738 int mprotect(void*, size_t, int); 739 } 740 else version (NetBSD) 741 { 742 int mprotect(void*, size_t, int); 743 } 744 else version (OpenBSD) 745 { 746 int mprotect(void*, size_t, int); 747 } 748 else version (DragonFlyBSD) 749 { 750 int mprotect(void*, size_t, int); 751 } 752 else version (Solaris) 753 { 754 int mprotect(void*, size_t, int); 755 } 756 else version (CRuntime_Bionic) 757 { 758 int mprotect(const scope void*, size_t, int); 759 } 760 else version (CRuntime_Musl) 761 { 762 int mprotect(void*, size_t, int); 763 } 764 else version (CRuntime_UClibc) 765 { 766 int mprotect(void*, size_t, int); 767 } 768 else 769 { 770 static assert(false, "Unsupported platform"); 771 } 772 773 // 774 // Shared Memory Objects (SHM) 775 // 776 /* 777 int shm_open(const scope char*, int, mode_t); 778 int shm_unlink(const scope char*); 779 */ 780 781 version (CRuntime_Glibc) 782 { 783 int shm_open(const scope char*, int, mode_t); 784 int shm_unlink(const scope char*); 785 } 786 else version (Darwin) 787 { 788 int shm_open(const scope char*, int, mode_t); 789 int shm_unlink(const scope char*); 790 } 791 else version (FreeBSD) 792 { 793 int shm_open(const scope char*, int, mode_t); 794 int shm_unlink(const scope char*); 795 } 796 else version (NetBSD) 797 { 798 int shm_open(const scope char*, int, mode_t); 799 int shm_unlink(const scope char*); 800 } 801 else version (OpenBSD) 802 { 803 int shm_open(const scope char*, int, mode_t); 804 int shm_unlink(const scope char*); 805 } 806 else version (DragonFlyBSD) 807 { 808 int shm_open(const scope char*, int, mode_t); 809 int shm_unlink(const scope char*); 810 } 811 else version (Solaris) 812 { 813 int shm_open(const scope char*, int, mode_t); 814 int shm_unlink(const scope char*); 815 } 816 else version (CRuntime_Bionic) 817 { 818 } 819 else version (CRuntime_Musl) 820 { 821 int shm_open(const scope char*, int, mode_t); 822 int shm_unlink(const scope char*); 823 } 824 else version (CRuntime_UClibc) 825 { 826 int shm_open(const scope char*, int, mode_t); 827 int shm_unlink(const scope char*); 828 } 829 else 830 { 831 static assert(false, "Unsupported platform"); 832 } 833 834 // 835 // Typed Memory Objects (TYM) 836 // 837 /* 838 POSIX_TYPED_MEM_ALLOCATE 839 POSIX_TYPED_MEM_ALLOCATE_CONTIG 840 POSIX_TYPED_MEM_MAP_ALLOCATABLE 841 842 struct posix_typed_mem_info 843 { 844 size_t posix_tmi_length; 845 } 846 847 int posix_mem_offset(const scope void*, size_t, off_t *, size_t *, int *); 848 int posix_typed_mem_get_info(int, struct posix_typed_mem_info *); 849 int posix_typed_mem_open(const scope char*, int, int); 850 */