| author | |
| committer | |
| log | 61c67a9833c312678289272e5e0547a78cbd299c |
| tree | 57d4c05946cd350cc137a73f8445f1233aa5b26d |
| parent | ab56d3e18ca7dbc430fdc2ca51fce08804cc3599 |
| signature |
9 files changed, 17 insertions(+), 440 deletions(-)
src-self-hosted/stage2.zig+2-5| ... | ... | @@ -909,12 +909,11 @@ export fn stage2_libc_render(stage1_libc: *Stage2LibCInstallation, output_file: |
| 909 | 909 | // ABI warning |
| 910 | 910 | const Stage2Target = extern struct { |
| 911 | 911 | arch: c_int, |
| 912 | sub_arch: c_int, | |
| 913 | ||
| 914 | 912 | vendor: c_int, |
| 915 | abi: c_int, | |
| 916 | 913 | |
| 914 | abi: c_int, | |
| 917 | 915 | os: c_int, |
| 916 | ||
| 918 | 917 | is_native: bool, |
| 919 | 918 | |
| 920 | 919 | glibc_version: ?*Stage2GLibCVersion, // null means default |
| ... | ... | @@ -928,7 +927,6 @@ const Stage2Target = extern struct { |
| 928 | 927 | if (in_target.is_native) return .Native; |
| 929 | 928 | |
| 930 | 929 | const in_arch = in_target.arch - 1; // skip over ZigLLVM_UnknownArch |
| 931 | const in_sub_arch = in_target.sub_arch - 1; // skip over ZigLLVM_NoSubArch | |
| 932 | 930 | const in_os = in_target.os; |
| 933 | 931 | const in_abi = in_target.abi; |
| 934 | 932 | |
| ... | ... | @@ -954,7 +952,6 @@ const Stage2Target = extern struct { |
| 954 | 952 | }; |
| 955 | 953 | self.* = .{ |
| 956 | 954 | .arch = @enumToInt(target.getArch()) + 1, // skip over ZigLLVM_UnknownArch |
| 957 | .sub_arch = 0, | |
| 958 | 955 | .vendor = 0, |
| 959 | 956 | .os = @enumToInt(target.getOs()), |
| 960 | 957 | .abi = @enumToInt(target.getAbi()), |
src/codegen.cpp-3| ... | ... | @@ -8711,7 +8711,6 @@ static Error define_builtin_compile_vars(CodeGen *g) { |
| 8711 | 8711 | cache_int(&cache_hash, g->code_model); |
| 8712 | 8712 | cache_int(&cache_hash, g->zig_target->is_native); |
| 8713 | 8713 | cache_int(&cache_hash, g->zig_target->arch); |
| 8714 | cache_int(&cache_hash, g->zig_target->sub_arch); | |
| 8715 | 8714 | cache_int(&cache_hash, g->zig_target->vendor); |
| 8716 | 8715 | cache_int(&cache_hash, g->zig_target->os); |
| 8717 | 8716 | cache_int(&cache_hash, g->zig_target->abi); |
| ... | ... | @@ -9616,7 +9615,6 @@ Error create_c_object_cache(CodeGen *g, CacheHash **out_cache_hash, bool verbose |
| 9616 | 9615 | cache_list_of_str(cache_hash, g->libc_include_dir_list, g->libc_include_dir_len); |
| 9617 | 9616 | cache_int(cache_hash, g->zig_target->is_native); |
| 9618 | 9617 | cache_int(cache_hash, g->zig_target->arch); |
| 9619 | cache_int(cache_hash, g->zig_target->sub_arch); | |
| 9620 | 9618 | cache_int(cache_hash, g->zig_target->vendor); |
| 9621 | 9619 | cache_int(cache_hash, g->zig_target->os); |
| 9622 | 9620 | cache_int(cache_hash, g->zig_target->abi); |
| ... | ... | @@ -10380,7 +10378,6 @@ static Error check_cache(CodeGen *g, Buf *manifest_dir, Buf *digest) { |
| 10380 | 10378 | cache_int(ch, g->out_type); |
| 10381 | 10379 | cache_bool(ch, g->zig_target->is_native); |
| 10382 | 10380 | cache_int(ch, g->zig_target->arch); |
| 10383 | cache_int(ch, g->zig_target->sub_arch); | |
| 10384 | 10381 | cache_int(ch, g->zig_target->vendor); |
| 10385 | 10382 | cache_int(ch, g->zig_target->os); |
| 10386 | 10383 | cache_int(ch, g->zig_target->abi); |
src/glibc.cpp+2-4| ... | ... | @@ -116,10 +116,8 @@ Error glibc_load_metadata(ZigGLibCAbi **out_result, Buf *zig_lib_dir, bool verbo |
| 116 | 116 | assert(opt_abi.is_some); |
| 117 | 117 | |
| 118 | 118 | |
| 119 | err = target_parse_archsub(&target->arch, &target->sub_arch, | |
| 120 | (char*)opt_arch.value.ptr, opt_arch.value.len); | |
| 121 | // there's no sub arch so we might get an error, but the arch is still populated | |
| 122 | assert(err == ErrorNone || err == ErrorUnknownArchitecture); | |
| 119 | err = target_parse_arch(&target->arch, (char*)opt_arch.value.ptr, opt_arch.value.len); | |
| 120 | assert(err == ErrorNone); | |
| 123 | 121 | |
| 124 | 122 | target->os = OsLinux; |
| 125 | 123 |
src/stage2.cpp+1-3| ... | ... | @@ -125,9 +125,7 @@ Error stage2_target_parse(struct ZigTarget *target, const char *zig_triple, cons |
| 125 | 125 | if (!opt_archsub.is_some) |
| 126 | 126 | return ErrorMissingArchitecture; |
| 127 | 127 | |
| 128 | if ((err = target_parse_archsub(&target->arch, &target->sub_arch, | |
| 129 | (char*)opt_archsub.value.ptr, opt_archsub.value.len))) | |
| 130 | { | |
| 128 | if ((err = target_parse_arch(&target->arch, (char*)opt_archsub.value.ptr, opt_archsub.value.len))) { | |
| 131 | 129 | return err; |
| 132 | 130 | } |
| 133 | 131 |
src/stage2.h+2-3| ... | ... | @@ -279,12 +279,11 @@ struct Stage2TargetData; |
| 279 | 279 | // ABI warning |
| 280 | 280 | struct ZigTarget { |
| 281 | 281 | enum ZigLLVM_ArchType arch; |
| 282 | enum ZigLLVM_SubArchType sub_arch; | |
| 283 | ||
| 284 | 282 | enum ZigLLVM_VendorType vendor; |
| 285 | enum ZigLLVM_EnvironmentType abi; | |
| 286 | 283 | |
| 284 | enum ZigLLVM_EnvironmentType abi; | |
| 287 | 285 | Os os; |
| 286 | ||
| 288 | 287 | bool is_native; |
| 289 | 288 | |
| 290 | 289 | struct ZigGLibCVersion *glibc_version; // null means default |
src/target.cpp+7-272| ... | ... | @@ -15,60 +15,6 @@ |
| 15 | 15 | |
| 16 | 16 | #include <stdio.h> |
| 17 | 17 | |
| 18 | static const SubArchList subarch_list_list[] = { | |
| 19 | SubArchListNone, | |
| 20 | SubArchListArm32, | |
| 21 | SubArchListArm64, | |
| 22 | SubArchListKalimba, | |
| 23 | SubArchListMips, | |
| 24 | }; | |
| 25 | ||
| 26 | static const ZigLLVM_SubArchType subarch_list_arm32[] = { | |
| 27 | ZigLLVM_ARMSubArch_v8_5a, | |
| 28 | ZigLLVM_ARMSubArch_v8_4a, | |
| 29 | ZigLLVM_ARMSubArch_v8_3a, | |
| 30 | ZigLLVM_ARMSubArch_v8_2a, | |
| 31 | ZigLLVM_ARMSubArch_v8_1a, | |
| 32 | ZigLLVM_ARMSubArch_v8, | |
| 33 | ZigLLVM_ARMSubArch_v8r, | |
| 34 | ZigLLVM_ARMSubArch_v8m_baseline, | |
| 35 | ZigLLVM_ARMSubArch_v8m_mainline, | |
| 36 | ZigLLVM_ARMSubArch_v8_1m_mainline, | |
| 37 | ZigLLVM_ARMSubArch_v7, | |
| 38 | ZigLLVM_ARMSubArch_v7em, | |
| 39 | ZigLLVM_ARMSubArch_v7m, | |
| 40 | ZigLLVM_ARMSubArch_v7s, | |
| 41 | ZigLLVM_ARMSubArch_v7k, | |
| 42 | ZigLLVM_ARMSubArch_v7ve, | |
| 43 | ZigLLVM_ARMSubArch_v6, | |
| 44 | ZigLLVM_ARMSubArch_v6m, | |
| 45 | ZigLLVM_ARMSubArch_v6k, | |
| 46 | ZigLLVM_ARMSubArch_v6t2, | |
| 47 | ZigLLVM_ARMSubArch_v5, | |
| 48 | ZigLLVM_ARMSubArch_v5te, | |
| 49 | ZigLLVM_ARMSubArch_v4t, | |
| 50 | ||
| 51 | }; | |
| 52 | ||
| 53 | static const ZigLLVM_SubArchType subarch_list_arm64[] = { | |
| 54 | ZigLLVM_ARMSubArch_v8_5a, | |
| 55 | ZigLLVM_ARMSubArch_v8_4a, | |
| 56 | ZigLLVM_ARMSubArch_v8_3a, | |
| 57 | ZigLLVM_ARMSubArch_v8_2a, | |
| 58 | ZigLLVM_ARMSubArch_v8_1a, | |
| 59 | ZigLLVM_ARMSubArch_v8, | |
| 60 | }; | |
| 61 | ||
| 62 | static const ZigLLVM_SubArchType subarch_list_kalimba[] = { | |
| 63 | ZigLLVM_KalimbaSubArch_v5, | |
| 64 | ZigLLVM_KalimbaSubArch_v4, | |
| 65 | ZigLLVM_KalimbaSubArch_v3, | |
| 66 | }; | |
| 67 | ||
| 68 | static const ZigLLVM_SubArchType subarch_list_mips[] = { | |
| 69 | ZigLLVM_MipsSubArch_r6, | |
| 70 | }; | |
| 71 | ||
| 72 | 18 | static const ZigLLVM_ArchType arch_list[] = { |
| 73 | 19 | ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale |
| 74 | 20 | ZigLLVM_armeb, // ARM (big endian): armeb |
| ... | ... | @@ -509,7 +455,6 @@ void get_native_target(ZigTarget *target) { |
| 509 | 455 | ZigLLVM_ObjectFormatType oformat; // ignored; based on arch/os |
| 510 | 456 | ZigLLVMGetNativeTarget( |
| 511 | 457 | &target->arch, |
| 512 | &target->sub_arch, | |
| 513 | 458 | &target->vendor, |
| 514 | 459 | &os_type, |
| 515 | 460 | &target->abi, |
| ... | ... | @@ -535,223 +480,18 @@ void target_init_default_glibc_version(ZigTarget *target) { |
| 535 | 480 | *target->glibc_version = {2, 17, 0}; |
| 536 | 481 | } |
| 537 | 482 | |
| 538 | Error target_parse_archsub(ZigLLVM_ArchType *out_arch, ZigLLVM_SubArchType *out_sub, | |
| 539 | const char *archsub_ptr, size_t archsub_len) | |
| 540 | { | |
| 483 | Error target_parse_arch(ZigLLVM_ArchType *out_arch, const char *arch_ptr, size_t arch_len) { | |
| 541 | 484 | *out_arch = ZigLLVM_UnknownArch; |
| 542 | *out_sub = ZigLLVM_NoSubArch; | |
| 543 | 485 | for (size_t arch_i = 0; arch_i < array_length(arch_list); arch_i += 1) { |
| 544 | 486 | ZigLLVM_ArchType arch = arch_list[arch_i]; |
| 545 | SubArchList sub_arch_list = target_subarch_list(arch); | |
| 546 | size_t subarch_count = target_subarch_count(sub_arch_list); | |
| 547 | if (mem_eql_str(archsub_ptr, archsub_len, target_arch_name(arch))) { | |
| 487 | if (mem_eql_str(arch_ptr, arch_len, target_arch_name(arch))) { | |
| 548 | 488 | *out_arch = arch; |
| 549 | if (subarch_count == 0) { | |
| 550 | return ErrorNone; | |
| 551 | } | |
| 552 | } | |
| 553 | for (size_t sub_i = 0; sub_i < subarch_count; sub_i += 1) { | |
| 554 | ZigLLVM_SubArchType sub = target_subarch_enum(sub_arch_list, sub_i); | |
| 555 | char arch_name[64]; | |
| 556 | int n = sprintf(arch_name, "%s%s", target_arch_name(arch), target_subarch_name(sub)); | |
| 557 | if (mem_eql_mem(arch_name, n, archsub_ptr, archsub_len)) { | |
| 558 | *out_arch = arch; | |
| 559 | *out_sub = sub; | |
| 560 | return ErrorNone; | |
| 561 | } | |
| 489 | return ErrorNone; | |
| 562 | 490 | } |
| 563 | 491 | } |
| 564 | 492 | return ErrorUnknownArchitecture; |
| 565 | 493 | } |
| 566 | 494 | |
| 567 | SubArchList target_subarch_list(ZigLLVM_ArchType arch) { | |
| 568 | switch (arch) { | |
| 569 | case ZigLLVM_UnknownArch: | |
| 570 | zig_unreachable(); | |
| 571 | case ZigLLVM_arm: | |
| 572 | case ZigLLVM_armeb: | |
| 573 | case ZigLLVM_thumb: | |
| 574 | case ZigLLVM_thumbeb: | |
| 575 | return SubArchListArm32; | |
| 576 | ||
| 577 | case ZigLLVM_aarch64: | |
| 578 | case ZigLLVM_aarch64_be: | |
| 579 | case ZigLLVM_aarch64_32: | |
| 580 | return SubArchListArm64; | |
| 581 | ||
| 582 | case ZigLLVM_kalimba: | |
| 583 | return SubArchListKalimba; | |
| 584 | ||
| 585 | case ZigLLVM_arc: | |
| 586 | case ZigLLVM_avr: | |
| 587 | case ZigLLVM_bpfel: | |
| 588 | case ZigLLVM_bpfeb: | |
| 589 | case ZigLLVM_hexagon: | |
| 590 | case ZigLLVM_mips: | |
| 591 | case ZigLLVM_mipsel: | |
| 592 | case ZigLLVM_mips64: | |
| 593 | case ZigLLVM_mips64el: | |
| 594 | case ZigLLVM_msp430: | |
| 595 | case ZigLLVM_ppc: | |
| 596 | case ZigLLVM_ppc64: | |
| 597 | case ZigLLVM_ppc64le: | |
| 598 | case ZigLLVM_r600: | |
| 599 | case ZigLLVM_amdgcn: | |
| 600 | case ZigLLVM_riscv32: | |
| 601 | case ZigLLVM_riscv64: | |
| 602 | case ZigLLVM_sparc: | |
| 603 | case ZigLLVM_sparcv9: | |
| 604 | case ZigLLVM_sparcel: | |
| 605 | case ZigLLVM_systemz: | |
| 606 | case ZigLLVM_tce: | |
| 607 | case ZigLLVM_tcele: | |
| 608 | case ZigLLVM_x86: | |
| 609 | case ZigLLVM_x86_64: | |
| 610 | case ZigLLVM_xcore: | |
| 611 | case ZigLLVM_nvptx: | |
| 612 | case ZigLLVM_nvptx64: | |
| 613 | case ZigLLVM_le32: | |
| 614 | case ZigLLVM_le64: | |
| 615 | case ZigLLVM_amdil: | |
| 616 | case ZigLLVM_amdil64: | |
| 617 | case ZigLLVM_hsail: | |
| 618 | case ZigLLVM_hsail64: | |
| 619 | case ZigLLVM_spir: | |
| 620 | case ZigLLVM_spir64: | |
| 621 | case ZigLLVM_shave: | |
| 622 | case ZigLLVM_lanai: | |
| 623 | case ZigLLVM_wasm32: | |
| 624 | case ZigLLVM_wasm64: | |
| 625 | case ZigLLVM_renderscript32: | |
| 626 | case ZigLLVM_renderscript64: | |
| 627 | return SubArchListNone; | |
| 628 | } | |
| 629 | zig_unreachable(); | |
| 630 | } | |
| 631 | ||
| 632 | size_t target_subarch_count(SubArchList sub_arch_list) { | |
| 633 | switch (sub_arch_list) { | |
| 634 | case SubArchListNone: | |
| 635 | return 0; | |
| 636 | case SubArchListArm32: | |
| 637 | return array_length(subarch_list_arm32); | |
| 638 | case SubArchListArm64: | |
| 639 | return array_length(subarch_list_arm64); | |
| 640 | case SubArchListKalimba: | |
| 641 | return array_length(subarch_list_kalimba); | |
| 642 | case SubArchListMips: | |
| 643 | return array_length(subarch_list_mips); | |
| 644 | } | |
| 645 | zig_unreachable(); | |
| 646 | } | |
| 647 | ||
| 648 | ZigLLVM_SubArchType target_subarch_enum(SubArchList sub_arch_list, size_t i) { | |
| 649 | switch (sub_arch_list) { | |
| 650 | case SubArchListNone: | |
| 651 | zig_unreachable(); | |
| 652 | case SubArchListArm32: | |
| 653 | assert(i < array_length(subarch_list_arm32)); | |
| 654 | return subarch_list_arm32[i]; | |
| 655 | case SubArchListArm64: | |
| 656 | assert(i < array_length(subarch_list_arm64)); | |
| 657 | return subarch_list_arm64[i]; | |
| 658 | case SubArchListKalimba: | |
| 659 | assert(i < array_length(subarch_list_kalimba)); | |
| 660 | return subarch_list_kalimba[i]; | |
| 661 | case SubArchListMips: | |
| 662 | assert(i < array_length(subarch_list_mips)); | |
| 663 | return subarch_list_mips[i]; | |
| 664 | } | |
| 665 | zig_unreachable(); | |
| 666 | } | |
| 667 | ||
| 668 | const char *target_subarch_name(ZigLLVM_SubArchType subarch) { | |
| 669 | switch (subarch) { | |
| 670 | case ZigLLVM_NoSubArch: | |
| 671 | return ""; | |
| 672 | case ZigLLVM_ARMSubArch_v8_5a: | |
| 673 | return "v8_5a"; | |
| 674 | case ZigLLVM_ARMSubArch_v8_4a: | |
| 675 | return "v8_4a"; | |
| 676 | case ZigLLVM_ARMSubArch_v8_3a: | |
| 677 | return "v8_3a"; | |
| 678 | case ZigLLVM_ARMSubArch_v8_2a: | |
| 679 | return "v8_2a"; | |
| 680 | case ZigLLVM_ARMSubArch_v8_1a: | |
| 681 | return "v8_1a"; | |
| 682 | case ZigLLVM_ARMSubArch_v8: | |
| 683 | return "v8a"; | |
| 684 | case ZigLLVM_ARMSubArch_v8r: | |
| 685 | return "v8r"; | |
| 686 | case ZigLLVM_ARMSubArch_v8m_baseline: | |
| 687 | return "v8m_baseline"; | |
| 688 | case ZigLLVM_ARMSubArch_v8m_mainline: | |
| 689 | return "v8m_mainline"; | |
| 690 | case ZigLLVM_ARMSubArch_v8_1m_mainline: | |
| 691 | return "v8_1m_mainline"; | |
| 692 | case ZigLLVM_ARMSubArch_v7: | |
| 693 | return "v7a"; | |
| 694 | case ZigLLVM_ARMSubArch_v7em: | |
| 695 | return "v7em"; | |
| 696 | case ZigLLVM_ARMSubArch_v7m: | |
| 697 | return "v7m"; | |
| 698 | case ZigLLVM_ARMSubArch_v7s: | |
| 699 | return "v7s"; | |
| 700 | case ZigLLVM_ARMSubArch_v7k: | |
| 701 | return "v7k"; | |
| 702 | case ZigLLVM_ARMSubArch_v7ve: | |
| 703 | return "v7ve"; | |
| 704 | case ZigLLVM_ARMSubArch_v6: | |
| 705 | return "v6"; | |
| 706 | case ZigLLVM_ARMSubArch_v6m: | |
| 707 | return "v6m"; | |
| 708 | case ZigLLVM_ARMSubArch_v6k: | |
| 709 | return "v6k"; | |
| 710 | case ZigLLVM_ARMSubArch_v6t2: | |
| 711 | return "v6t2"; | |
| 712 | case ZigLLVM_ARMSubArch_v5: | |
| 713 | return "v5"; | |
| 714 | case ZigLLVM_ARMSubArch_v5te: | |
| 715 | return "v5te"; | |
| 716 | case ZigLLVM_ARMSubArch_v4t: | |
| 717 | return "v4t"; | |
| 718 | case ZigLLVM_KalimbaSubArch_v3: | |
| 719 | return "v3"; | |
| 720 | case ZigLLVM_KalimbaSubArch_v4: | |
| 721 | return "v4"; | |
| 722 | case ZigLLVM_KalimbaSubArch_v5: | |
| 723 | return "v5"; | |
| 724 | case ZigLLVM_MipsSubArch_r6: | |
| 725 | return "r6"; | |
| 726 | } | |
| 727 | zig_unreachable(); | |
| 728 | } | |
| 729 | ||
| 730 | size_t target_subarch_list_count(void) { | |
| 731 | return array_length(subarch_list_list); | |
| 732 | } | |
| 733 | ||
| 734 | SubArchList target_subarch_list_enum(size_t index) { | |
| 735 | assert(index < array_length(subarch_list_list)); | |
| 736 | return subarch_list_list[index]; | |
| 737 | } | |
| 738 | ||
| 739 | const char *target_subarch_list_name(SubArchList sub_arch_list) { | |
| 740 | switch (sub_arch_list) { | |
| 741 | case SubArchListNone: | |
| 742 | return "None"; | |
| 743 | case SubArchListArm32: | |
| 744 | return "Arm32"; | |
| 745 | case SubArchListArm64: | |
| 746 | return "Arm64"; | |
| 747 | case SubArchListKalimba: | |
| 748 | return "Kalimba"; | |
| 749 | case SubArchListMips: | |
| 750 | return "Mips"; | |
| 751 | } | |
| 752 | zig_unreachable(); | |
| 753 | } | |
| 754 | ||
| 755 | 495 | Error target_parse_os(Os *out_os, const char *os_ptr, size_t os_len) { |
| 756 | 496 | for (size_t i = 0; i < array_length(os_list); i += 1) { |
| 757 | 497 | Os os = os_list[i]; |
| ... | ... | @@ -794,18 +534,16 @@ void init_all_targets(void) { |
| 794 | 534 | |
| 795 | 535 | void target_triple_zig(Buf *triple, const ZigTarget *target) { |
| 796 | 536 | buf_resize(triple, 0); |
| 797 | buf_appendf(triple, "%s%s-%s-%s", | |
| 537 | buf_appendf(triple, "%s-%s-%s", | |
| 798 | 538 | target_arch_name(target->arch), |
| 799 | target_subarch_name(target->sub_arch), | |
| 800 | 539 | target_os_name(target->os), |
| 801 | 540 | target_abi_name(target->abi)); |
| 802 | 541 | } |
| 803 | 542 | |
| 804 | 543 | void target_triple_llvm(Buf *triple, const ZigTarget *target) { |
| 805 | 544 | buf_resize(triple, 0); |
| 806 | buf_appendf(triple, "%s%s-%s-%s-%s", | |
| 545 | buf_appendf(triple, "%s-%s-%s-%s", | |
| 807 | 546 | ZigLLVMGetArchTypeName(target->arch), |
| 808 | ZigLLVMGetSubArchTypeName(target->sub_arch), | |
| 809 | 547 | ZigLLVMGetVendorTypeName(target->vendor), |
| 810 | 548 | ZigLLVMGetOSTypeName(get_llvm_os_type(target->os)), |
| 811 | 549 | ZigLLVMGetEnvironmentTypeName(target->abi)); |
| ... | ... | @@ -1182,10 +920,8 @@ bool target_can_exec(const ZigTarget *host_target, const ZigTarget *guest_target |
| 1182 | 920 | return true; |
| 1183 | 921 | } |
| 1184 | 922 | |
| 1185 | if (guest_target->os == host_target->os && guest_target->arch == host_target->arch && | |
| 1186 | guest_target->sub_arch == host_target->sub_arch) | |
| 1187 | { | |
| 1188 | // OS, arch, and sub-arch match | |
| 923 | if (guest_target->os == host_target->os && guest_target->arch == host_target->arch) { | |
| 924 | // OS and arch match | |
| 1189 | 925 | return true; |
| 1190 | 926 | } |
| 1191 | 927 | |
| ... | ... | @@ -1607,7 +1343,6 @@ void target_libc_enum(size_t index, ZigTarget *out_target) { |
| 1607 | 1343 | out_target->arch = libcs_available[index].arch; |
| 1608 | 1344 | out_target->os = libcs_available[index].os; |
| 1609 | 1345 | out_target->abi = libcs_available[index].abi; |
| 1610 | out_target->sub_arch = ZigLLVM_NoSubArch; | |
| 1611 | 1346 | out_target->vendor = ZigLLVM_UnknownVendor; |
| 1612 | 1347 | out_target->is_native = false; |
| 1613 | 1348 | } |
src/target.hpp+1-20| ... | ... | @@ -12,15 +12,6 @@ |
| 12 | 12 | |
| 13 | 13 | struct Buf; |
| 14 | 14 | |
| 15 | // Synchronize with target.cpp::subarch_list_list | |
| 16 | enum SubArchList { | |
| 17 | SubArchListNone, | |
| 18 | SubArchListArm32, | |
| 19 | SubArchListArm64, | |
| 20 | SubArchListKalimba, | |
| 21 | SubArchListMips, | |
| 22 | }; | |
| 23 | ||
| 24 | 15 | enum TargetSubsystem { |
| 25 | 16 | TargetSubsystemConsole, |
| 26 | 17 | TargetSubsystemWindows, |
| ... | ... | @@ -51,8 +42,7 @@ enum CIntType { |
| 51 | 42 | }; |
| 52 | 43 | |
| 53 | 44 | Error target_parse_triple(ZigTarget *target, const char *triple, const char *mcpu); |
| 54 | Error target_parse_archsub(ZigLLVM_ArchType *arch, ZigLLVM_SubArchType *sub, | |
| 55 | const char *archsub_ptr, size_t archsub_len); | |
| 45 | Error target_parse_arch(ZigLLVM_ArchType *arch, const char *arch_ptr, size_t arch_len); | |
| 56 | 46 | Error target_parse_os(Os *os, const char *os_ptr, size_t os_len); |
| 57 | 47 | Error target_parse_abi(ZigLLVM_EnvironmentType *abi, const char *abi_ptr, size_t abi_len); |
| 58 | 48 | |
| ... | ... | @@ -63,15 +53,6 @@ size_t target_arch_count(void); |
| 63 | 53 | ZigLLVM_ArchType target_arch_enum(size_t index); |
| 64 | 54 | const char *target_arch_name(ZigLLVM_ArchType arch); |
| 65 | 55 | |
| 66 | SubArchList target_subarch_list(ZigLLVM_ArchType arch); | |
| 67 | size_t target_subarch_count(SubArchList sub_arch_list); | |
| 68 | ZigLLVM_SubArchType target_subarch_enum(SubArchList subarch_list, size_t index); | |
| 69 | const char *target_subarch_name(ZigLLVM_SubArchType subarch); | |
| 70 | ||
| 71 | size_t target_subarch_list_count(void); | |
| 72 | SubArchList target_subarch_list_enum(size_t index); | |
| 73 | const char *target_subarch_list_name(SubArchList sub_arch_list); | |
| 74 | ||
| 75 | 56 | const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch); |
| 76 | 57 | |
| 77 | 58 | size_t target_vendor_count(void); |
src/zig_llvm.cpp+1-93| ... | ... | @@ -806,7 +806,7 @@ const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType env_type) { |
| 806 | 806 | return (const char*)Triple::getEnvironmentTypeName((Triple::EnvironmentType)env_type).bytes_begin(); |
| 807 | 807 | } |
| 808 | 808 | |
| 809 | void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *sub_arch_type, | |
| 809 | void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, | |
| 810 | 810 | ZigLLVM_VendorType *vendor_type, ZigLLVM_OSType *os_type, ZigLLVM_EnvironmentType *environ_type, |
| 811 | 811 | ZigLLVM_ObjectFormatType *oformat) |
| 812 | 812 | { |
| ... | ... | @@ -814,7 +814,6 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *su |
| 814 | 814 | Triple triple(Triple::normalize(native_triple)); |
| 815 | 815 | |
| 816 | 816 | *arch_type = (ZigLLVM_ArchType)triple.getArch(); |
| 817 | *sub_arch_type = (ZigLLVM_SubArchType)triple.getSubArch(); | |
| 818 | 817 | *vendor_type = (ZigLLVM_VendorType)triple.getVendor(); |
| 819 | 818 | *os_type = (ZigLLVM_OSType)triple.getOS(); |
| 820 | 819 | *environ_type = (ZigLLVM_EnvironmentType)triple.getEnvironment(); |
| ... | ... | @@ -823,68 +822,6 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *su |
| 823 | 822 | free(native_triple); |
| 824 | 823 | } |
| 825 | 824 | |
| 826 | const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) { | |
| 827 | switch (sub_arch) { | |
| 828 | case ZigLLVM_NoSubArch: | |
| 829 | return ""; | |
| 830 | case ZigLLVM_ARMSubArch_v8_5a: | |
| 831 | return "v8.5a"; | |
| 832 | case ZigLLVM_ARMSubArch_v8_4a: | |
| 833 | return "v8.4a"; | |
| 834 | case ZigLLVM_ARMSubArch_v8_3a: | |
| 835 | return "v8.3a"; | |
| 836 | case ZigLLVM_ARMSubArch_v8_2a: | |
| 837 | return "v8.2a"; | |
| 838 | case ZigLLVM_ARMSubArch_v8_1a: | |
| 839 | return "v8.1a"; | |
| 840 | case ZigLLVM_ARMSubArch_v8: | |
| 841 | return "v8a"; | |
| 842 | case ZigLLVM_ARMSubArch_v8r: | |
| 843 | return "v8r"; | |
| 844 | case ZigLLVM_ARMSubArch_v8m_baseline: | |
| 845 | return "v8m.base"; | |
| 846 | case ZigLLVM_ARMSubArch_v8m_mainline: | |
| 847 | return "v8m.main"; | |
| 848 | case ZigLLVM_ARMSubArch_v8_1m_mainline: | |
| 849 | return "v8.1m.main"; | |
| 850 | case ZigLLVM_ARMSubArch_v7: | |
| 851 | return "v7a"; | |
| 852 | case ZigLLVM_ARMSubArch_v7em: | |
| 853 | return "v7em"; | |
| 854 | case ZigLLVM_ARMSubArch_v7m: | |
| 855 | return "v7m"; | |
| 856 | case ZigLLVM_ARMSubArch_v7s: | |
| 857 | return "v7s"; | |
| 858 | case ZigLLVM_ARMSubArch_v7k: | |
| 859 | return "v7k"; | |
| 860 | case ZigLLVM_ARMSubArch_v7ve: | |
| 861 | return "v7ve"; | |
| 862 | case ZigLLVM_ARMSubArch_v6: | |
| 863 | return "v6"; | |
| 864 | case ZigLLVM_ARMSubArch_v6m: | |
| 865 | return "v6m"; | |
| 866 | case ZigLLVM_ARMSubArch_v6k: | |
| 867 | return "v6k"; | |
| 868 | case ZigLLVM_ARMSubArch_v6t2: | |
| 869 | return "v6t2"; | |
| 870 | case ZigLLVM_ARMSubArch_v5: | |
| 871 | return "v5"; | |
| 872 | case ZigLLVM_ARMSubArch_v5te: | |
| 873 | return "v5te"; | |
| 874 | case ZigLLVM_ARMSubArch_v4t: | |
| 875 | return "v4t"; | |
| 876 | case ZigLLVM_KalimbaSubArch_v3: | |
| 877 | return "v3"; | |
| 878 | case ZigLLVM_KalimbaSubArch_v4: | |
| 879 | return "v4"; | |
| 880 | case ZigLLVM_KalimbaSubArch_v5: | |
| 881 | return "v5"; | |
| 882 | case ZigLLVM_MipsSubArch_r6: | |
| 883 | return "r6"; | |
| 884 | } | |
| 885 | abort(); | |
| 886 | } | |
| 887 | ||
| 888 | 825 | void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module) { |
| 889 | 826 | unwrap(module)->addModuleFlag(Module::Warning, "Debug Info Version", DEBUG_METADATA_VERSION); |
| 890 | 827 | unwrap(module)->addModuleFlag(Module::Warning, "Dwarf Version", 4); |
| ... | ... | @@ -1218,35 +1155,6 @@ static_assert((Triple::ArchType)ZigLLVM_renderscript32 == Triple::renderscript32 |
| 1218 | 1155 | static_assert((Triple::ArchType)ZigLLVM_renderscript64 == Triple::renderscript64, ""); |
| 1219 | 1156 | static_assert((Triple::ArchType)ZigLLVM_LastArchType == Triple::LastArchType, ""); |
| 1220 | 1157 | |
| 1221 | static_assert((Triple::SubArchType)ZigLLVM_NoSubArch == Triple::NoSubArch, ""); | |
| 1222 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_4a == Triple::ARMSubArch_v8_4a, ""); | |
| 1223 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_3a == Triple::ARMSubArch_v8_3a, ""); | |
| 1224 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_2a == Triple::ARMSubArch_v8_2a, ""); | |
| 1225 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_1a == Triple::ARMSubArch_v8_1a, ""); | |
| 1226 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8 == Triple::ARMSubArch_v8, ""); | |
| 1227 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8r == Triple::ARMSubArch_v8r, ""); | |
| 1228 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_baseline == Triple::ARMSubArch_v8m_baseline, ""); | |
| 1229 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8m_mainline == Triple::ARMSubArch_v8m_mainline, ""); | |
| 1230 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v8_1m_mainline == Triple::ARMSubArch_v8_1m_mainline, ""); | |
| 1231 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7 == Triple::ARMSubArch_v7, ""); | |
| 1232 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7em == Triple::ARMSubArch_v7em, ""); | |
| 1233 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7m == Triple::ARMSubArch_v7m, ""); | |
| 1234 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7s == Triple::ARMSubArch_v7s, ""); | |
| 1235 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7k == Triple::ARMSubArch_v7k, ""); | |
| 1236 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v7ve == Triple::ARMSubArch_v7ve, ""); | |
| 1237 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6 == Triple::ARMSubArch_v6, ""); | |
| 1238 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6m == Triple::ARMSubArch_v6m, ""); | |
| 1239 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6k == Triple::ARMSubArch_v6k, ""); | |
| 1240 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v6t2 == Triple::ARMSubArch_v6t2, ""); | |
| 1241 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5 == Triple::ARMSubArch_v5, ""); | |
| 1242 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v5te == Triple::ARMSubArch_v5te, ""); | |
| 1243 | static_assert((Triple::SubArchType)ZigLLVM_ARMSubArch_v4t == Triple::ARMSubArch_v4t, ""); | |
| 1244 | static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v3 == Triple::KalimbaSubArch_v3, ""); | |
| 1245 | static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v4 == Triple::KalimbaSubArch_v4, ""); | |
| 1246 | static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, ""); | |
| 1247 | static_assert((Triple::SubArchType)ZigLLVM_KalimbaSubArch_v5 == Triple::KalimbaSubArch_v5, ""); | |
| 1248 | static_assert((Triple::SubArchType)ZigLLVM_MipsSubArch_r6 == Triple::MipsSubArch_r6, ""); | |
| 1249 | ||
| 1250 | 1158 | static_assert((Triple::VendorType)ZigLLVM_UnknownVendor == Triple::UnknownVendor, ""); |
| 1251 | 1159 | static_assert((Triple::VendorType)ZigLLVM_Apple == Triple::Apple, ""); |
| 1252 | 1160 | static_assert((Triple::VendorType)ZigLLVM_PC == Triple::PC, ""); |
src/zig_llvm.h+1-37| ... | ... | @@ -324,41 +324,6 @@ enum ZigLLVM_ArchType { |
| 324 | 324 | ZigLLVM_LastArchType = ZigLLVM_renderscript64 |
| 325 | 325 | }; |
| 326 | 326 | |
| 327 | // synchronize with lists in target.cpp | |
| 328 | enum ZigLLVM_SubArchType { | |
| 329 | ZigLLVM_NoSubArch, | |
| 330 | ||
| 331 | ZigLLVM_ARMSubArch_v8_5a, | |
| 332 | ZigLLVM_ARMSubArch_v8_4a, | |
| 333 | ZigLLVM_ARMSubArch_v8_3a, | |
| 334 | ZigLLVM_ARMSubArch_v8_2a, | |
| 335 | ZigLLVM_ARMSubArch_v8_1a, | |
| 336 | ZigLLVM_ARMSubArch_v8, | |
| 337 | ZigLLVM_ARMSubArch_v8r, | |
| 338 | ZigLLVM_ARMSubArch_v8m_baseline, | |
| 339 | ZigLLVM_ARMSubArch_v8m_mainline, | |
| 340 | ZigLLVM_ARMSubArch_v8_1m_mainline, | |
| 341 | ZigLLVM_ARMSubArch_v7, | |
| 342 | ZigLLVM_ARMSubArch_v7em, | |
| 343 | ZigLLVM_ARMSubArch_v7m, | |
| 344 | ZigLLVM_ARMSubArch_v7s, | |
| 345 | ZigLLVM_ARMSubArch_v7k, | |
| 346 | ZigLLVM_ARMSubArch_v7ve, | |
| 347 | ZigLLVM_ARMSubArch_v6, | |
| 348 | ZigLLVM_ARMSubArch_v6m, | |
| 349 | ZigLLVM_ARMSubArch_v6k, | |
| 350 | ZigLLVM_ARMSubArch_v6t2, | |
| 351 | ZigLLVM_ARMSubArch_v5, | |
| 352 | ZigLLVM_ARMSubArch_v5te, | |
| 353 | ZigLLVM_ARMSubArch_v4t, | |
| 354 | ||
| 355 | ZigLLVM_KalimbaSubArch_v3, | |
| 356 | ZigLLVM_KalimbaSubArch_v4, | |
| 357 | ZigLLVM_KalimbaSubArch_v5, | |
| 358 | ||
| 359 | ZigLLVM_MipsSubArch_r6, | |
| 360 | }; | |
| 361 | ||
| 362 | 327 | enum ZigLLVM_VendorType { |
| 363 | 328 | ZigLLVM_UnknownVendor, |
| 364 | 329 | |
| ... | ... | @@ -518,7 +483,6 @@ LLVMValueRef ZigLLVMBuildAtomicRMW(LLVMBuilderRef B, enum ZigLLVM_AtomicRMWBinOp |
| 518 | 483 | #define ZigLLVM_DIFlags_AllCallsDescribed (1U << 29) |
| 519 | 484 | |
| 520 | 485 | ZIG_EXTERN_C const char *ZigLLVMGetArchTypeName(enum ZigLLVM_ArchType arch); |
| 521 | ZIG_EXTERN_C const char *ZigLLVMGetSubArchTypeName(enum ZigLLVM_SubArchType sub_arch); | |
| 522 | 486 | ZIG_EXTERN_C const char *ZigLLVMGetVendorTypeName(enum ZigLLVM_VendorType vendor); |
| 523 | 487 | ZIG_EXTERN_C const char *ZigLLVMGetOSTypeName(enum ZigLLVM_OSType os); |
| 524 | 488 | ZIG_EXTERN_C const char *ZigLLVMGetEnvironmentTypeName(enum ZigLLVM_EnvironmentType abi); |
| ... | ... | @@ -532,7 +496,7 @@ ZIG_EXTERN_C bool ZigLLVMWriteArchive(const char *archive_name, const char **fil |
| 532 | 496 | bool ZigLLVMWriteImportLibrary(const char *def_path, const enum ZigLLVM_ArchType arch, |
| 533 | 497 | const char *output_lib_path, const bool kill_at); |
| 534 | 498 | |
| 535 | ZIG_EXTERN_C void ZigLLVMGetNativeTarget(enum ZigLLVM_ArchType *arch_type, enum ZigLLVM_SubArchType *sub_arch_type, | |
| 499 | ZIG_EXTERN_C void ZigLLVMGetNativeTarget(enum ZigLLVM_ArchType *arch_type, | |
| 536 | 500 | enum ZigLLVM_VendorType *vendor_type, enum ZigLLVM_OSType *os_type, enum ZigLLVM_EnvironmentType *environ_type, |
| 537 | 501 | enum ZigLLVM_ObjectFormatType *oformat); |
| 538 | 502 |