authorgravatar for topolarity@tapscott.meCody Tapscott <topolarity@tapscott.me> 2022-10-21 18:56:18-07:00
committergravatar for topolarity@tapscott.meCody Tapscott <topolarity@tapscott.me> 2022-10-21 19:11:47-07:00
logddbdb83c865b1124487b3a00747fc5c1a67e5770
treef12ebc2c5d56af896aa64b5b7a36a51d0d65c992
parent8d4778b4f9c731b2e9fab0b968e1ca6864fd3a72

stage 2: Update C types' size/alignment

These updates were made by testing against the `sizeof/_Alignof` reported by Clang for all supported arch-OS-ABI combinations and correcting any discrepancies. This is bound to have a few errors (the recent long double fix for i386 Android is one example), but Clang is certainly not a bad place to start, especially for our most popular targets.

2 files changed, 352 insertions(+), 142 deletions(-)

lib/std/target.zig+76-55
......@@ -1781,68 +1781,89 @@ pub const Target = struct {
17811781 }
17821782
17831783 pub inline fn longDoubleIs(target: Target, comptime F: type) bool {
1784 if (target.abi == .msvc or (target.abi == .android and target.cpu.arch == .i386)) {
1785 return F == f64;
1786 }
1787 return switch (F) {
1788 f128 => switch (target.cpu.arch) {
1789 .aarch64 => {
1790 // According to Apple's official guide:
1791 // > The long double type is a double precision IEEE754 binary floating-point type,
1792 // > which makes it identical to the double type. This behavior contrasts to the
1793 // > standard specification, in which a long double is a quad-precision, IEEE754
1794 // > binary, floating-point type.
1795 // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
1796 return !target.isDarwin();
1784 switch (target.os.tag) {
1785 .windows, .uefi => switch (target.abi) {
1786 .gnu, .gnuilp32, .cygnus => switch (target.cpu.arch) {
1787 .i386 => return F == f80,
1788 .x86_64 => return F == f128,
1789 else => return F == f64,
17971790 },
1791 else => return F == f64,
1792 },
1793 else => {},
1794 }
17981795
1799 .riscv64,
1800 .aarch64_be,
1801 .aarch64_32,
1802 .s390x,
1803 .mips64,
1804 .mips64el,
1805 .sparc,
1806 .sparc64,
1807 .sparcel,
1808 .powerpc,
1809 .powerpcle,
1810 .powerpc64,
1811 .powerpc64le,
1812 .wasm32,
1813 .wasm64,
1814 => true,
1796 if (target.abi == .android and target.cpu.arch == .i386)
1797 return F == f64;
18151798
1816 else => false,
1799 switch (target.cpu.arch) {
1800 .aarch64,
1801 .aarch64_be,
1802 .aarch64_32,
1803 => switch (target.os.tag) {
1804 // According to Apple's official guide:
1805 // > The long double type is a double precision IEEE754 binary floating-point type,
1806 // > which makes it identical to the double type. This behavior contrasts to the
1807 // > standard specification, in which a long double is a quad-precision, IEEE754
1808 // > binary, floating-point type.
1809 // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
1810 .ios, .macos, .watchos, .tvos => return F == f64,
1811 .windows, .uefi => return F == f64,
1812 else => return F == f128,
18171813 },
1818 f80 => switch (target.cpu.arch) {
1819 .x86_64, .i386 => true,
1820 else => false,
1814
1815 .i386 => return F == f80,
1816 .x86_64 => return F == f80,
1817
1818 .mips64,
1819 .mips64el,
1820 => switch (target.os.tag) {
1821 .freebsd => return F == f64,
1822 else => return F == f128,
18211823 },
1822 f64 => switch (target.cpu.arch) {
1823 .aarch64 => target.isDarwin(),
18241824
1825 .x86_64,
1826 .i386,
1827 .riscv64,
1828 .aarch64_be,
1829 .aarch64_32,
1830 .s390x,
1831 .mips64,
1832 .mips64el,
1833 .sparc,
1834 .sparc64,
1835 .sparcel,
1836 .powerpc,
1837 .powerpcle,
1838 .powerpc64,
1839 .powerpc64le,
1840 => false,
1825 .powerpc,
1826 .powerpcle,
1827 => switch (target.abi) {
1828 .musl,
1829 .musleabi,
1830 .musleabihf,
1831 .muslx32,
1832 => return F == f64,
1833 else => switch (target.os.tag) {
1834 .freebsd, .netbsd, .openbsd => return F == f64,
1835 else => return F == f128,
1836 },
1837 },
18411838
1842 else => true,
1839 .powerpc64,
1840 .powerpc64le,
1841 => switch (target.abi) {
1842 .musl,
1843 .musleabi,
1844 .musleabihf,
1845 .muslx32,
1846 => return F == f64,
1847 else => switch (target.os.tag) {
1848 .freebsd, .openbsd => return F == f64,
1849 else => return F == f128,
1850 },
18431851 },
1844 else => false,
1845 };
1852
1853 .riscv32,
1854 .riscv64,
1855 .s390x,
1856 .sparc,
1857 .sparc64,
1858 .sparcel,
1859 .wasm32,
1860 .wasm64,
1861 => return F == f128,
1862
1863 .avr, .tce, .tcele => return F == f32,
1864
1865 else => return F == f64,
1866 }
18461867 }
18471868
18481869 pub inline fn maxIntAlignment(target: Target) u16 {
......@@ -1872,7 +1893,7 @@ pub const Target = struct {
18721893 => 8,
18731894
18741895 .i386 => return switch (target.os.tag) {
1875 .windows => 8,
1896 .windows, .uefi => 8,
18761897 else => 4,
18771898 },
18781899
src/type.zig+276-87
......@@ -2892,41 +2892,24 @@ pub const Type = extern union {
28922892 .anyframe_T,
28932893 => return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },
28942894
2895 .c_short => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.short.sizeInBits(target), 8) },
2896 .c_ushort => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ushort.sizeInBits(target), 8) },
2897 .c_int => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.int.sizeInBits(target), 8) },
2898 .c_uint => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.uint.sizeInBits(target), 8) },
2899 .c_long => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.long.sizeInBits(target), 8) },
2900 .c_ulong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulong.sizeInBits(target), 8) },
2901 .c_longlong => switch (target.cpu.arch) {
2902 .i386 => switch (target.os.tag) {
2903 .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
2904 else => return AbiAlignmentAdvanced{ .scalar = 4 },
2905 },
2906 else => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.longlong.sizeInBits(target), 8) },
2907 },
2908 .c_ulonglong => switch (target.cpu.arch) {
2909 .i386 => switch (target.os.tag) {
2910 .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
2911 else => return AbiAlignmentAdvanced{ .scalar = 4 },
2912 },
2913 else => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulonglong.sizeInBits(target), 8) },
2914 },
2895 .c_short => return AbiAlignmentAdvanced{ .scalar = CType.short.alignment(target) },
2896 .c_ushort => return AbiAlignmentAdvanced{ .scalar = CType.ushort.alignment(target) },
2897 .c_int => return AbiAlignmentAdvanced{ .scalar = CType.int.alignment(target) },
2898 .c_uint => return AbiAlignmentAdvanced{ .scalar = CType.uint.alignment(target) },
2899 .c_long => return AbiAlignmentAdvanced{ .scalar = CType.long.alignment(target) },
2900 .c_ulong => return AbiAlignmentAdvanced{ .scalar = CType.ulong.alignment(target) },
2901 .c_longlong => return AbiAlignmentAdvanced{ .scalar = CType.longlong.alignment(target) },
2902 .c_ulonglong => return AbiAlignmentAdvanced{ .scalar = CType.ulonglong.alignment(target) },
2903 .c_longdouble => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
29152904
29162905 .f16 => return AbiAlignmentAdvanced{ .scalar = 2 },
2917 .f32 => return AbiAlignmentAdvanced{ .scalar = 4 },
2918 .f64 => switch (target.cpu.arch) {
2919 .i386 => switch (target.os.tag) {
2920 .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
2921 else => return AbiAlignmentAdvanced{ .scalar = 4 },
2922 },
2906 .f32 => return AbiAlignmentAdvanced{ .scalar = CType.float.alignment(target) },
2907 .f64 => switch (CType.double.sizeInBits(target)) {
2908 64 => return AbiAlignmentAdvanced{ .scalar = CType.double.alignment(target) },
29232909 else => return AbiAlignmentAdvanced{ .scalar = 8 },
29242910 },
2925 .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
2926
2927 .f80 => switch (target.cpu.arch) {
2928 .i386 => return AbiAlignmentAdvanced{ .scalar = 4 },
2929 .x86_64 => return AbiAlignmentAdvanced{ .scalar = 16 },
2911 .f80 => switch (CType.longdouble.sizeInBits(target)) {
2912 80 => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
29302913 else => {
29312914 var payload: Payload.Bits = .{
29322915 .base = .{ .tag = .int_unsigned },
......@@ -2936,17 +2919,7 @@ pub const Type = extern union {
29362919 return AbiAlignmentAdvanced{ .scalar = abiAlignment(u80_ty, target) };
29372920 },
29382921 },
2939 .c_longdouble => switch (CType.longdouble.sizeInBits(target)) {
2940 16 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f16, target) },
2941 32 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f32, target) },
2942 64 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f64, target) },
2943 80 => if (target.cpu.arch == .i386 and target.isMinGW())
2944 return AbiAlignmentAdvanced{ .scalar = 4 }
2945 else
2946 return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f80, target) },
2947 128 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f128, target) },
2948 else => unreachable,
2949 },
2922 .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
29502923
29512924 // TODO revisit this when we have the concept of the error tag type
29522925 .anyerror_void_error_union,
......@@ -3411,16 +3384,8 @@ pub const Type = extern union {
34113384 .f32 => return AbiSizeAdvanced{ .scalar = 4 },
34123385 .f64 => return AbiSizeAdvanced{ .scalar = 8 },
34133386 .f128 => return AbiSizeAdvanced{ .scalar = 16 },
3414
3415 .f80 => switch (target.cpu.arch) {
3416 .i386 => switch (target.os.tag) {
3417 .windows => switch (target.abi) {
3418 .msvc => return AbiSizeAdvanced{ .scalar = 16 },
3419 else => return AbiSizeAdvanced{ .scalar = 12 },
3420 },
3421 else => return AbiSizeAdvanced{ .scalar = 12 },
3422 },
3423 .x86_64 => return AbiSizeAdvanced{ .scalar = 16 },
3387 .f80 => switch (CType.longdouble.sizeInBits(target)) {
3388 80 => return AbiSizeAdvanced{ .scalar = std.mem.alignForward(10, CType.longdouble.alignment(target)) },
34243389 else => {
34253390 var payload: Payload.Bits = .{
34263391 .base = .{ .tag = .int_unsigned },
......@@ -6654,45 +6619,80 @@ pub const CType = enum {
66546619 ulonglong,
66556620 longdouble,
66566621
6622 // We don't have a `c_float`/`c_double` type in Zig, but these
6623 // are useful for querying target-correct alignment and checking
6624 // whether C's double is f64 or f32
6625 float,
6626 double,
6627
66576628 pub fn sizeInBits(self: CType, target: Target) u16 {
66586629 switch (target.os.tag) {
66596630 .freestanding, .other => switch (target.cpu.arch) {
66606631 .msp430 => switch (self) {
66616632 .short, .ushort, .int, .uint => return 16,
6662 .long, .ulong => return 32,
6663 .longlong, .ulonglong, .longdouble => return 64,
6633 .float, .long, .ulong => return 32,
6634 .longlong, .ulonglong, .double, .longdouble => return 64,
66646635 },
66656636 .avr => switch (self) {
66666637 .short, .ushort, .int, .uint => return 16,
6667 .long, .ulong, .longdouble => return 32,
6638 .long, .ulong, .float, .double, .longdouble => return 32,
66686639 .longlong, .ulonglong => return 64,
66696640 },
6641 .tce, .tcele => switch (self) {
6642 .short, .ushort => return 16,
6643 .int, .uint, .long, .ulong, .longlong, .ulonglong => return 32,
6644 .float, .double, .longdouble => return 32,
6645 },
6646 .mips64, .mips64el => switch (self) {
6647 .short, .ushort => return 16,
6648 .int, .uint, .float => return 32,
6649 .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
6650 .longlong, .ulonglong, .double => return 64,
6651 .longdouble => return 128,
6652 },
6653 .x86_64 => switch (self) {
6654 .short, .ushort => return 16,
6655 .int, .uint, .float => return 32,
6656 .long, .ulong => switch (target.abi) {
6657 .gnux32, .muslx32 => return 32,
6658 else => return 64,
6659 },
6660 .longlong, .ulonglong, .double => return 64,
6661 .longdouble => return 80,
6662 },
66706663 else => switch (self) {
66716664 .short, .ushort => return 16,
6672 .int, .uint => return 32,
6665 .int, .uint, .float => return 32,
66736666 .long, .ulong => return target.cpu.arch.ptrBitWidth(),
6674 .longlong, .ulonglong => return 64,
6667 .longlong, .ulonglong, .double => return 64,
66756668 .longdouble => switch (target.cpu.arch) {
66766669 .i386 => switch (target.abi) {
66776670 .android => return 64,
66786671 else => return 80,
66796672 },
6680 .x86_64 => return 80,
66816673
6674 .powerpc,
6675 .powerpcle,
6676 .powerpc64,
6677 .powerpc64le,
6678 => switch (target.abi) {
6679 .musl,
6680 .musleabi,
6681 .musleabihf,
6682 .muslx32,
6683 => return 64,
6684 else => return 128,
6685 },
6686
6687 .riscv32,
66826688 .riscv64,
66836689 .aarch64,
66846690 .aarch64_be,
66856691 .aarch64_32,
66866692 .s390x,
6687 .mips64,
6688 .mips64el,
66896693 .sparc,
66906694 .sparc64,
66916695 .sparcel,
6692 .powerpc,
6693 .powerpcle,
6694 .powerpc64,
6695 .powerpc64le,
66966696 .wasm32,
66976697 .wasm64,
66986698 => return 128,
......@@ -6716,23 +6716,78 @@ pub const CType = enum {
67166716 .fuchsia,
67176717 .minix,
67186718 => switch (target.cpu.arch) {
6719 .msp430 => switch (self) {
6720 .short, .ushort, .int, .uint => return 16,
6721 .long, .ulong, .float => return 32,
6722 .longlong, .ulonglong, .double, .longdouble => return 64,
6723 },
67196724 .avr => switch (self) {
67206725 .short, .ushort, .int, .uint => return 16,
6721 .long, .ulong, .longdouble => return 32,
6726 .long, .ulong, .float, .double, .longdouble => return 32,
67226727 .longlong, .ulonglong => return 64,
67236728 },
6729 .tce, .tcele => switch (self) {
6730 .short, .ushort => return 16,
6731 .int, .uint, .long, .ulong, .longlong, .ulonglong => return 32,
6732 .float, .double, .longdouble => return 32,
6733 },
6734 .mips64, .mips64el => switch (self) {
6735 .short, .ushort => return 16,
6736 .int, .uint, .float => return 32,
6737 .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
6738 .longlong, .ulonglong, .double => return 64,
6739 .longdouble => if (target.os.tag == .freebsd) return 64 else return 128,
6740 },
6741 .x86_64 => switch (self) {
6742 .short, .ushort => return 16,
6743 .int, .uint, .float => return 32,
6744 .long, .ulong => switch (target.abi) {
6745 .gnux32, .muslx32 => return 32,
6746 else => return 64,
6747 },
6748 .longlong, .ulonglong, .double => return 64,
6749 .longdouble => return 80,
6750 },
67246751 else => switch (self) {
67256752 .short, .ushort => return 16,
6726 .int, .uint => return 32,
6753 .int, .uint, .float => return 32,
67276754 .long, .ulong => return target.cpu.arch.ptrBitWidth(),
6728 .longlong, .ulonglong => return 64,
6755 .longlong, .ulonglong, .double => return 64,
67296756 .longdouble => switch (target.cpu.arch) {
67306757 .i386 => switch (target.abi) {
67316758 .android => return 64,
67326759 else => return 80,
67336760 },
6734 .x86_64 => return 80,
67356761
6762 .powerpc,
6763 .powerpcle,
6764 => switch (target.abi) {
6765 .musl,
6766 .musleabi,
6767 .musleabihf,
6768 .muslx32,
6769 => return 64,
6770 else => switch (target.os.tag) {
6771 .freebsd, .netbsd, .openbsd => return 64,
6772 else => return 128,
6773 },
6774 },
6775
6776 .powerpc64,
6777 .powerpc64le,
6778 => switch (target.abi) {
6779 .musl,
6780 .musleabi,
6781 .musleabihf,
6782 .muslx32,
6783 => return 64,
6784 else => switch (target.os.tag) {
6785 .freebsd, .openbsd => return 64,
6786 else => return 128,
6787 },
6788 },
6789
6790 .riscv32,
67366791 .riscv64,
67376792 .aarch64,
67386793 .aarch64_be,
......@@ -6743,10 +6798,6 @@ pub const CType = enum {
67436798 .sparc,
67446799 .sparc64,
67456800 .sparcel,
6746 .powerpc,
6747 .powerpcle,
6748 .powerpc64,
6749 .powerpc64le,
67506801 .wasm32,
67516802 .wasm64,
67526803 => return 128,
......@@ -6756,37 +6807,65 @@ pub const CType = enum {
67566807 },
67576808 },
67586809
6759 .windows, .uefi => switch (self) {
6760 .short, .ushort => return 16,
6761 .int, .uint, .long, .ulong => return 32,
6762 .longlong, .ulonglong => return 64,
6763 .longdouble => switch (target.cpu.arch) {
6764 .i386 => switch (target.abi) {
6765 .gnu => return 80,
6810 .windows, .uefi => switch (target.cpu.arch) {
6811 .i386 => switch (self) {
6812 .short, .ushort => return 16,
6813 .int, .uint, .float => return 32,
6814 .long, .ulong => return 32,
6815 .longlong, .ulonglong, .double => return 64,
6816 .longdouble => switch (target.abi) {
6817 .gnu, .gnuilp32, .cygnus => return 80,
67666818 else => return 64,
67676819 },
6768 .x86_64 => switch (target.abi) {
6769 .gnu => return 80,
6820 },
6821 .x86_64 => switch (self) {
6822 .short, .ushort => return 16,
6823 .int, .uint, .float => return 32,
6824 .long, .ulong => switch (target.abi) {
6825 .cygnus => return 64,
6826 else => return 32,
6827 },
6828 .longlong, .ulonglong, .double => return 64,
6829 .longdouble => switch (target.abi) {
6830 .gnu, .gnuilp32, .cygnus => return 128,
67706831 else => return 64,
67716832 },
6772 else => return 64,
6833 },
6834 else => switch (self) {
6835 .short, .ushort => return 16,
6836 .int, .uint, .float => return 32,
6837 .long, .ulong => return 32,
6838 .longlong, .ulonglong, .double => return 64,
6839 .longdouble => return 64,
67736840 },
67746841 },
67756842
67766843 .macos, .ios, .tvos, .watchos => switch (self) {
67776844 .short, .ushort => return 16,
6778 .int, .uint => return 32,
6779 .long, .ulong, .longlong, .ulonglong => return 64,
6845 .int, .uint, .float => return 32,
6846 .long, .ulong => switch (target.cpu.arch) {
6847 .i386, .arm, .aarch64_32 => return 32,
6848 .x86_64 => switch (target.abi) {
6849 .gnux32, .muslx32 => return 32,
6850 else => return 64,
6851 },
6852 else => return 64,
6853 },
6854 .longlong, .ulonglong, .double => return 64,
67806855 .longdouble => switch (target.cpu.arch) {
6781 .i386, .x86_64 => return 80,
6856 .i386 => switch (target.abi) {
6857 .android => return 64,
6858 else => return 80,
6859 },
6860 .x86_64 => return 80,
67826861 else => return 64,
67836862 },
67846863 },
67856864
67866865 .amdhsa, .amdpal => switch (self) {
67876866 .short, .ushort => return 16,
6788 .int, .uint => return 32,
6789 .long, .ulong, .longlong, .ulonglong => return 64,
6867 .int, .uint, .float => return 32,
6868 .long, .ulong, .longlong, .ulonglong, .double => return 64,
67906869 .longdouble => return 128,
67916870 },
67926871
......@@ -6814,4 +6893,114 @@ pub const CType = enum {
68146893 => @panic("TODO specify the C integer and float type sizes for this OS"),
68156894 }
68166895 }
6896
6897 pub fn alignment(self: CType, target: Target) u16 {
6898
6899 // Overrides for unusual alignments
6900 switch (target.cpu.arch) {
6901 .avr => switch (self) {
6902 .short, .ushort => return 2,
6903 else => return 1,
6904 },
6905 .i386 => switch (target.os.tag) {
6906 .windows, .uefi => switch (self) {
6907 .longlong, .ulonglong, .double => return 8,
6908 .longdouble => switch (target.abi) {
6909 .gnu, .gnuilp32, .cygnus => return 4,
6910 else => return 8,
6911 },
6912 else => {},
6913 },
6914 else => {},
6915 },
6916 else => {},
6917 }
6918
6919 // Self-aligned, up to a maximum.
6920 return @min(
6921 std.math.ceilPowerOfTwoAssert(u16, (self.sizeInBits(target) + 7) / 8),
6922 switch (target.cpu.arch) {
6923 .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
6924 .netbsd => switch (target.abi) {
6925 .gnueabi,
6926 .gnueabihf,
6927 .eabi,
6928 .eabihf,
6929 .android,
6930 .musleabi,
6931 .musleabihf,
6932 => 8,
6933
6934 else => @as(u16, 4),
6935 },
6936 .ios, .tvos, .watchos => 4,
6937 else => 8,
6938 },
6939
6940 .msp430,
6941 .avr,
6942 => 2,
6943
6944 .arc,
6945 .csky,
6946 .i386,
6947 .xcore,
6948 .dxil,
6949 .loongarch32,
6950 .tce,
6951 .tcele,
6952 .le32,
6953 .amdil,
6954 .hsail,
6955 .spir,
6956 .spirv32,
6957 .kalimba,
6958 .shave,
6959 .renderscript32,
6960 .ve,
6961 .spu_2,
6962 => 4,
6963
6964 .aarch64_32,
6965 .amdgcn,
6966 .amdil64,
6967 .bpfel,
6968 .bpfeb,
6969 .hexagon,
6970 .hsail64,
6971 .loongarch64,
6972 .m68k,
6973 .mips,
6974 .mipsel,
6975 .sparc,
6976 .sparcel,
6977 .sparc64,
6978 .lanai,
6979 .le64,
6980 .nvptx,
6981 .nvptx64,
6982 .r600,
6983 .s390x,
6984 .spir64,
6985 .spirv64,
6986 .renderscript64,
6987 => 8,
6988
6989 .aarch64,
6990 .aarch64_be,
6991 .mips64,
6992 .mips64el,
6993 .powerpc,
6994 .powerpcle,
6995 .powerpc64,
6996 .powerpc64le,
6997 .riscv32,
6998 .riscv64,
6999 .x86_64,
7000 .wasm32,
7001 .wasm64,
7002 => 16,
7003 },
7004 );
7005 }
68177006};