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 {...@@ -1781,68 +1781,89 @@ pub const Target = struct {
1781 }1781 }
17821782
1783 pub inline fn longDoubleIs(target: Target, comptime F: type) bool {1783 pub inline fn longDoubleIs(target: Target, comptime F: type) bool {
1784 if (target.abi == .msvc or (target.abi == .android and target.cpu.arch == .i386)) {1784 switch (target.os.tag) {
1785 return F == f64;1785 .windows, .uefi => switch (target.abi) {
1786 }1786 .gnu, .gnuilp32, .cygnus => switch (target.cpu.arch) {
1787 return switch (F) {1787 .i386 => return F == f80,
1788 f128 => switch (target.cpu.arch) {1788 .x86_64 => return F == f128,
1789 .aarch64 => {1789 else => return F == f64,
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();
1797 },1790 },
1791 else => return F == f64,
1792 },
1793 else => {},
1794 }
17981795
1799 .riscv64,1796 if (target.abi == .android and target.cpu.arch == .i386)
1800 .aarch64_be,1797 return F == f64;
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,
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,
1817 },1813 },
1818 f80 => switch (target.cpu.arch) {1814
1819 .x86_64, .i386 => true,1815 .i386 => return F == f80,
1820 else => false,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,
1821 },1823 },
1822 f64 => switch (target.cpu.arch) {
1823 .aarch64 => target.isDarwin(),
18241824
1825 .x86_64,1825 .powerpc,
1826 .i386,1826 .powerpcle,
1827 .riscv64,1827 => switch (target.abi) {
1828 .aarch64_be,1828 .musl,
1829 .aarch64_32,1829 .musleabi,
1830 .s390x,1830 .musleabihf,
1831 .mips64,1831 .muslx32,
1832 .mips64el,1832 => return F == f64,
1833 .sparc,1833 else => switch (target.os.tag) {
1834 .sparc64,1834 .freebsd, .netbsd, .openbsd => return F == f64,
1835 .sparcel,1835 else => return F == f128,
1836 .powerpc,1836 },
1837 .powerpcle,1837 },
1838 .powerpc64,
1839 .powerpc64le,
1840 => false,
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 },
1843 },1851 },
1844 else => false,1852
1845 };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 }
1846 }1867 }
18471868
1848 pub inline fn maxIntAlignment(target: Target) u16 {1869 pub inline fn maxIntAlignment(target: Target) u16 {
...@@ -1872,7 +1893,7 @@ pub const Target = struct {...@@ -1872,7 +1893,7 @@ pub const Target = struct {
1872 => 8,1893 => 8,
18731894
1874 .i386 => return switch (target.os.tag) {1895 .i386 => return switch (target.os.tag) {
1875 .windows => 8,1896 .windows, .uefi => 8,
1876 else => 4,1897 else => 4,
1877 },1898 },
18781899
src/type.zig+276-87
...@@ -2892,41 +2892,24 @@ pub const Type = extern union {...@@ -2892,41 +2892,24 @@ pub const Type = extern union {
2892 .anyframe_T,2892 .anyframe_T,
2893 => return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },2893 => return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },
28942894
2895 .c_short => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.short.sizeInBits(target), 8) },2895 .c_short => return AbiAlignmentAdvanced{ .scalar = CType.short.alignment(target) },
2896 .c_ushort => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ushort.sizeInBits(target), 8) },2896 .c_ushort => return AbiAlignmentAdvanced{ .scalar = CType.ushort.alignment(target) },
2897 .c_int => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.int.sizeInBits(target), 8) },2897 .c_int => return AbiAlignmentAdvanced{ .scalar = CType.int.alignment(target) },
2898 .c_uint => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.uint.sizeInBits(target), 8) },2898 .c_uint => return AbiAlignmentAdvanced{ .scalar = CType.uint.alignment(target) },
2899 .c_long => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.long.sizeInBits(target), 8) },2899 .c_long => return AbiAlignmentAdvanced{ .scalar = CType.long.alignment(target) },
2900 .c_ulong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulong.sizeInBits(target), 8) },2900 .c_ulong => return AbiAlignmentAdvanced{ .scalar = CType.ulong.alignment(target) },
2901 .c_longlong => switch (target.cpu.arch) {2901 .c_longlong => return AbiAlignmentAdvanced{ .scalar = CType.longlong.alignment(target) },
2902 .i386 => switch (target.os.tag) {2902 .c_ulonglong => return AbiAlignmentAdvanced{ .scalar = CType.ulonglong.alignment(target) },
2903 .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },2903 .c_longdouble => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
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 },
29152904
2916 .f16 => return AbiAlignmentAdvanced{ .scalar = 2 },2905 .f16 => return AbiAlignmentAdvanced{ .scalar = 2 },
2917 .f32 => return AbiAlignmentAdvanced{ .scalar = 4 },2906 .f32 => return AbiAlignmentAdvanced{ .scalar = CType.float.alignment(target) },
2918 .f64 => switch (target.cpu.arch) {2907 .f64 => switch (CType.double.sizeInBits(target)) {
2919 .i386 => switch (target.os.tag) {2908 64 => return AbiAlignmentAdvanced{ .scalar = CType.double.alignment(target) },
2920 .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
2921 else => return AbiAlignmentAdvanced{ .scalar = 4 },
2922 },
2923 else => return AbiAlignmentAdvanced{ .scalar = 8 },2909 else => return AbiAlignmentAdvanced{ .scalar = 8 },
2924 },2910 },
2925 .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },2911 .f80 => switch (CType.longdouble.sizeInBits(target)) {
29262912 80 => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
2927 .f80 => switch (target.cpu.arch) {
2928 .i386 => return AbiAlignmentAdvanced{ .scalar = 4 },
2929 .x86_64 => return AbiAlignmentAdvanced{ .scalar = 16 },
2930 else => {2913 else => {
2931 var payload: Payload.Bits = .{2914 var payload: Payload.Bits = .{
2932 .base = .{ .tag = .int_unsigned },2915 .base = .{ .tag = .int_unsigned },
...@@ -2936,17 +2919,7 @@ pub const Type = extern union {...@@ -2936,17 +2919,7 @@ pub const Type = extern union {
2936 return AbiAlignmentAdvanced{ .scalar = abiAlignment(u80_ty, target) };2919 return AbiAlignmentAdvanced{ .scalar = abiAlignment(u80_ty, target) };
2937 },2920 },
2938 },2921 },
2939 .c_longdouble => switch (CType.longdouble.sizeInBits(target)) {2922 .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
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 },
29502923
2951 // TODO revisit this when we have the concept of the error tag type2924 // TODO revisit this when we have the concept of the error tag type
2952 .anyerror_void_error_union,2925 .anyerror_void_error_union,
...@@ -3411,16 +3384,8 @@ pub const Type = extern union {...@@ -3411,16 +3384,8 @@ pub const Type = extern union {
3411 .f32 => return AbiSizeAdvanced{ .scalar = 4 },3384 .f32 => return AbiSizeAdvanced{ .scalar = 4 },
3412 .f64 => return AbiSizeAdvanced{ .scalar = 8 },3385 .f64 => return AbiSizeAdvanced{ .scalar = 8 },
3413 .f128 => return AbiSizeAdvanced{ .scalar = 16 },3386 .f128 => return AbiSizeAdvanced{ .scalar = 16 },
34143387 .f80 => switch (CType.longdouble.sizeInBits(target)) {
3415 .f80 => switch (target.cpu.arch) {3388 80 => return AbiSizeAdvanced{ .scalar = std.mem.alignForward(10, CType.longdouble.alignment(target)) },
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 },
3424 else => {3389 else => {
3425 var payload: Payload.Bits = .{3390 var payload: Payload.Bits = .{
3426 .base = .{ .tag = .int_unsigned },3391 .base = .{ .tag = .int_unsigned },
...@@ -6654,45 +6619,80 @@ pub const CType = enum {...@@ -6654,45 +6619,80 @@ pub const CType = enum {
6654 ulonglong,6619 ulonglong,
6655 longdouble,6620 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
6657 pub fn sizeInBits(self: CType, target: Target) u16 {6628 pub fn sizeInBits(self: CType, target: Target) u16 {
6658 switch (target.os.tag) {6629 switch (target.os.tag) {
6659 .freestanding, .other => switch (target.cpu.arch) {6630 .freestanding, .other => switch (target.cpu.arch) {
6660 .msp430 => switch (self) {6631 .msp430 => switch (self) {
6661 .short, .ushort, .int, .uint => return 16,6632 .short, .ushort, .int, .uint => return 16,
6662 .long, .ulong => return 32,6633 .float, .long, .ulong => return 32,
6663 .longlong, .ulonglong, .longdouble => return 64,6634 .longlong, .ulonglong, .double, .longdouble => return 64,
6664 },6635 },
6665 .avr => switch (self) {6636 .avr => switch (self) {
6666 .short, .ushort, .int, .uint => return 16,6637 .short, .ushort, .int, .uint => return 16,
6667 .long, .ulong, .longdouble => return 32,6638 .long, .ulong, .float, .double, .longdouble => return 32,
6668 .longlong, .ulonglong => return 64,6639 .longlong, .ulonglong => return 64,
6669 },6640 },
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 },
6670 else => switch (self) {6663 else => switch (self) {
6671 .short, .ushort => return 16,6664 .short, .ushort => return 16,
6672 .int, .uint => return 32,6665 .int, .uint, .float => return 32,
6673 .long, .ulong => return target.cpu.arch.ptrBitWidth(),6666 .long, .ulong => return target.cpu.arch.ptrBitWidth(),
6674 .longlong, .ulonglong => return 64,6667 .longlong, .ulonglong, .double => return 64,
6675 .longdouble => switch (target.cpu.arch) {6668 .longdouble => switch (target.cpu.arch) {
6676 .i386 => switch (target.abi) {6669 .i386 => switch (target.abi) {
6677 .android => return 64,6670 .android => return 64,
6678 else => return 80,6671 else => return 80,
6679 },6672 },
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,
6682 .riscv64,6688 .riscv64,
6683 .aarch64,6689 .aarch64,
6684 .aarch64_be,6690 .aarch64_be,
6685 .aarch64_32,6691 .aarch64_32,
6686 .s390x,6692 .s390x,
6687 .mips64,
6688 .mips64el,
6689 .sparc,6693 .sparc,
6690 .sparc64,6694 .sparc64,
6691 .sparcel,6695 .sparcel,
6692 .powerpc,
6693 .powerpcle,
6694 .powerpc64,
6695 .powerpc64le,
6696 .wasm32,6696 .wasm32,
6697 .wasm64,6697 .wasm64,
6698 => return 128,6698 => return 128,
...@@ -6716,23 +6716,78 @@ pub const CType = enum {...@@ -6716,23 +6716,78 @@ pub const CType = enum {
6716 .fuchsia,6716 .fuchsia,
6717 .minix,6717 .minix,
6718 => switch (target.cpu.arch) {6718 => 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 },
6719 .avr => switch (self) {6724 .avr => switch (self) {
6720 .short, .ushort, .int, .uint => return 16,6725 .short, .ushort, .int, .uint => return 16,
6721 .long, .ulong, .longdouble => return 32,6726 .long, .ulong, .float, .double, .longdouble => return 32,
6722 .longlong, .ulonglong => return 64,6727 .longlong, .ulonglong => return 64,
6723 },6728 },
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 },
6724 else => switch (self) {6751 else => switch (self) {
6725 .short, .ushort => return 16,6752 .short, .ushort => return 16,
6726 .int, .uint => return 32,6753 .int, .uint, .float => return 32,
6727 .long, .ulong => return target.cpu.arch.ptrBitWidth(),6754 .long, .ulong => return target.cpu.arch.ptrBitWidth(),
6728 .longlong, .ulonglong => return 64,6755 .longlong, .ulonglong, .double => return 64,
6729 .longdouble => switch (target.cpu.arch) {6756 .longdouble => switch (target.cpu.arch) {
6730 .i386 => switch (target.abi) {6757 .i386 => switch (target.abi) {
6731 .android => return 64,6758 .android => return 64,
6732 else => return 80,6759 else => return 80,
6733 },6760 },
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,
6736 .riscv64,6791 .riscv64,
6737 .aarch64,6792 .aarch64,
6738 .aarch64_be,6793 .aarch64_be,
...@@ -6743,10 +6798,6 @@ pub const CType = enum {...@@ -6743,10 +6798,6 @@ pub const CType = enum {
6743 .sparc,6798 .sparc,
6744 .sparc64,6799 .sparc64,
6745 .sparcel,6800 .sparcel,
6746 .powerpc,
6747 .powerpcle,
6748 .powerpc64,
6749 .powerpc64le,
6750 .wasm32,6801 .wasm32,
6751 .wasm64,6802 .wasm64,
6752 => return 128,6803 => return 128,
...@@ -6756,37 +6807,65 @@ pub const CType = enum {...@@ -6756,37 +6807,65 @@ pub const CType = enum {
6756 },6807 },
6757 },6808 },
67586809
6759 .windows, .uefi => switch (self) {6810 .windows, .uefi => switch (target.cpu.arch) {
6760 .short, .ushort => return 16,6811 .i386 => switch (self) {
6761 .int, .uint, .long, .ulong => return 32,6812 .short, .ushort => return 16,
6762 .longlong, .ulonglong => return 64,6813 .int, .uint, .float => return 32,
6763 .longdouble => switch (target.cpu.arch) {6814 .long, .ulong => return 32,
6764 .i386 => switch (target.abi) {6815 .longlong, .ulonglong, .double => return 64,
6765 .gnu => return 80,6816 .longdouble => switch (target.abi) {
6817 .gnu, .gnuilp32, .cygnus => return 80,
6766 else => return 64,6818 else => return 64,
6767 },6819 },
6768 .x86_64 => switch (target.abi) {6820 },
6769 .gnu => return 80,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,
6770 else => return 64,6831 else => return 64,
6771 },6832 },
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,
6773 },6840 },
6774 },6841 },
67756842
6776 .macos, .ios, .tvos, .watchos => switch (self) {6843 .macos, .ios, .tvos, .watchos => switch (self) {
6777 .short, .ushort => return 16,6844 .short, .ushort => return 16,
6778 .int, .uint => return 32,6845 .int, .uint, .float => return 32,
6779 .long, .ulong, .longlong, .ulonglong => return 64,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,
6780 .longdouble => switch (target.cpu.arch) {6855 .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,
6782 else => return 64,6861 else => return 64,
6783 },6862 },
6784 },6863 },
67856864
6786 .amdhsa, .amdpal => switch (self) {6865 .amdhsa, .amdpal => switch (self) {
6787 .short, .ushort => return 16,6866 .short, .ushort => return 16,
6788 .int, .uint => return 32,6867 .int, .uint, .float => return 32,
6789 .long, .ulong, .longlong, .ulonglong => return 64,6868 .long, .ulong, .longlong, .ulonglong, .double => return 64,
6790 .longdouble => return 128,6869 .longdouble => return 128,
6791 },6870 },
67926871
...@@ -6814,4 +6893,114 @@ pub const CType = enum {...@@ -6814,4 +6893,114 @@ pub const CType = enum {
6814 => @panic("TODO specify the C integer and float type sizes for this OS"),6893 => @panic("TODO specify the C integer and float type sizes for this OS"),
6815 }6894 }
6816 }6895 }
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 }
6817};7006};