From 802c4b57f7ea4ee9e1752b1c6cf930959beeb0d2 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 30 Mar 2024 01:11:56 +0900 Subject: [PATCH] fixes --- docker/dragonfly.Dockerfile | 5 +- ...piler_builtins+m68k-unknown-linux-gnu.diff | 12 ++ ...libc+armv5te-unknown-linux-uclibceabi.diff | 104 +++++++++--------- .../libc+armv7-unknown-linux-uclibceabi.diff | 104 +++++++++--------- ...libc+armv7-unknown-linux-uclibceabihf.diff | 104 +++++++++--------- .../libc+mips-unknown-linux-uclibc.diff | 104 +++++++++--------- .../libc+mipsel-unknown-linux-uclibc.diff | 104 +++++++++--------- .../libc+x86_64-unknown-dragonfly.diff | 51 +++++++++ .../std+armv5te-unknown-linux-uclibceabi.diff | 14 +++ .../std+armv7-unknown-linux-uclibceabi.diff | 14 +++ .../std+armv7-unknown-linux-uclibceabihf.diff | 14 +++ .../std+mips-unknown-linux-uclibc.diff | 14 +++ .../std+mipsel-unknown-linux-uclibc.diff | 14 +++ platform-support-status-tier3.md | 2 +- tools/target-list-shared.sh | 2 +- 15 files changed, 398 insertions(+), 264 deletions(-) create mode 100644 docker/test-base/patches/compiler_builtins+m68k-unknown-linux-gnu.diff create mode 100644 docker/test-base/patches/libc+x86_64-unknown-dragonfly.diff create mode 100644 docker/test-base/patches/std+armv5te-unknown-linux-uclibceabi.diff create mode 100644 docker/test-base/patches/std+armv7-unknown-linux-uclibceabi.diff create mode 100644 docker/test-base/patches/std+armv7-unknown-linux-uclibceabihf.diff create mode 100644 docker/test-base/patches/std+mips-unknown-linux-uclibc.diff create mode 100644 docker/test-base/patches/std+mipsel-unknown-linux-uclibc.diff diff --git a/docker/dragonfly.Dockerfile b/docker/dragonfly.Dockerfile index 921bd9c..61997a5 100644 --- a/docker/dragonfly.Dockerfile +++ b/docker/dragonfly.Dockerfile @@ -10,8 +10,9 @@ FROM ghcr.io/taiki-e/downloader as sysroot SHELL ["/bin/bash", "-eEuxo", "pipefail", "-c"] ARG DRAGONFLY_VERSION RUN mkdir -p /sysroot -# https://mirror-master.dragonflybsd.org/iso-images -RUN curl --proto '=https' --tlsv1.2 -fsSL --retry 10 --retry-connrefused "https://mirror-master.dragonflybsd.org/iso-images/dfly-x86_64-${DRAGONFLY_VERSION}_REL.iso.bz2" \ +# https://mirror-master.dragonflybsd.org/iso-images's certificate has expired... +# https://cdimage.debian.org/mirror/dragonflybsd.org/iso-images +RUN curl --proto '=https' --tlsv1.2 -fsSL --retry 10 --retry-connrefused "https://cdimage.debian.org/mirror/dragonflybsd.org/iso-images/dfly-x86_64-${DRAGONFLY_VERSION}_REL.iso.bz2" \ | bsdtar xjf - -C /sysroot ./lib ./usr/include ./usr/lib FROM ghcr.io/taiki-e/build-base:ubuntu-"${UBUNTU_VERSION}" as builder diff --git a/docker/test-base/patches/compiler_builtins+m68k-unknown-linux-gnu.diff b/docker/test-base/patches/compiler_builtins+m68k-unknown-linux-gnu.diff new file mode 100644 index 0000000..c96ffd4 --- /dev/null +++ b/docker/test-base/patches/compiler_builtins+m68k-unknown-linux-gnu.diff @@ -0,0 +1,12 @@ +diff --git a/src/mem/mod.rs b/src/mem/mod.rs +index ccf1917..dcbbf52 100644 +--- a/src/mem/mod.rs ++++ b/src/mem/mod.rs +@@ -130,6 +130,7 @@ fn memset_element_unordered_atomic(s: *mut T, c: u8, bytes: usize) + } + } + ++#[cfg(not(target_arch = "m68k"))] + intrinsics! { + #[cfg(target_has_atomic_load_store = "8")] + pub unsafe extern "C" fn __llvm_memcpy_element_unordered_atomic_1(dest: *mut u8, src: *const u8, bytes: usize) -> () { diff --git a/docker/test-base/patches/libc+armv5te-unknown-linux-uclibceabi.diff b/docker/test-base/patches/libc+armv5te-unknown-linux-uclibceabi.diff index 92ed8bb..87a1e0e 100644 --- a/docker/test-base/patches/libc+armv5te-unknown-linux-uclibceabi.diff +++ b/docker/test-base/patches/libc+armv5te-unknown-linux-uclibceabi.diff @@ -1,70 +1,70 @@ diff --git a/src/unix/linux_like/linux/uclibc/mod.rs b/src/unix/linux_like/linux/uclibc/mod.rs -index 4afb98e95..67d5ba1b3 100644 +index 48b03e9ee..3df2f7b3c 100644 --- a/src/unix/linux_like/linux/uclibc/mod.rs +++ b/src/unix/linux_like/linux/uclibc/mod.rs @@ -107,6 +107,68 @@ struct siginfo_si_value { } } -+cfg_if! { -+ if #[cfg(libc_union)] { -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ struct sifields_sigchld { -+ si_pid: ::pid_t, -+ si_uid: ::uid_t, -+ si_status: ::c_int, -+ si_utime: ::c_long, -+ si_stime: ::c_long, -+ } -+ impl ::Copy for sifields_sigchld {} -+ impl ::Clone for sifields_sigchld { -+ fn clone(&self) -> sifields_sigchld { -+ *self -+ } -+ } ++extern "C" { ++ pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; ++} ++ ++// Internal, for casts to access union fields ++#[repr(C)] ++struct sifields_sigchld { ++ si_pid: ::pid_t, ++ si_uid: ::uid_t, ++ si_status: ::c_int, ++ si_utime: ::c_long, ++ si_stime: ::c_long, ++} ++impl ::Copy for sifields_sigchld {} ++impl ::Clone for sifields_sigchld { ++ fn clone(&self) -> sifields_sigchld { ++ *self ++ } ++} + -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ union sifields { -+ _align_pointer: *mut ::c_void, -+ sigchld: sifields_sigchld, -+ } ++// Internal, for casts to access union fields ++#[repr(C)] ++union sifields { ++ _align_pointer: *mut ::c_void, ++ sigchld: sifields_sigchld, ++} + -+ // Internal, for casts to access union fields. Note that some variants -+ // of sifields start with a pointer, which makes the alignment of -+ // sifields vary on 32-bit and 64-bit architectures. -+ #[repr(C)] -+ struct siginfo_f { -+ _siginfo_base: [::c_int; 3], -+ sifields: sifields, -+ } ++// Internal, for casts to access union fields. Note that some variants ++// of sifields start with a pointer, which makes the alignment of ++// sifields vary on 32-bit and 64-bit architectures. ++#[repr(C)] ++struct siginfo_f { ++ _siginfo_base: [::c_int; 3], ++ sifields: sifields, ++} + -+ impl siginfo_t { -+ unsafe fn sifields(&self) -> &sifields { -+ &(*(self as *const siginfo_t as *const siginfo_f)).sifields -+ } ++impl siginfo_t { ++ unsafe fn sifields(&self) -> &sifields { ++ &(*(self as *const siginfo_t as *const siginfo_f)).sifields ++ } + -+ pub unsafe fn si_pid(&self) -> ::pid_t { -+ self.sifields().sigchld.si_pid -+ } ++ pub unsafe fn si_pid(&self) -> ::pid_t { ++ self.sifields().sigchld.si_pid ++ } + -+ pub unsafe fn si_uid(&self) -> ::uid_t { -+ self.sifields().sigchld.si_uid -+ } ++ pub unsafe fn si_uid(&self) -> ::uid_t { ++ self.sifields().sigchld.si_uid ++ } + -+ pub unsafe fn si_status(&self) -> ::c_int { -+ self.sifields().sigchld.si_status -+ } ++ pub unsafe fn si_status(&self) -> ::c_int { ++ self.sifields().sigchld.si_status ++ } + -+ pub unsafe fn si_utime(&self) -> ::c_long { -+ self.sifields().sigchld.si_utime -+ } ++ pub unsafe fn si_utime(&self) -> ::c_long { ++ self.sifields().sigchld.si_utime ++ } + -+ pub unsafe fn si_stime(&self) -> ::c_long { -+ self.sifields().sigchld.si_stime -+ } -+ } ++ pub unsafe fn si_stime(&self) -> ::c_long { ++ self.sifields().sigchld.si_stime + } +} + diff --git a/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabi.diff b/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabi.diff index 92ed8bb..87a1e0e 100644 --- a/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabi.diff +++ b/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabi.diff @@ -1,70 +1,70 @@ diff --git a/src/unix/linux_like/linux/uclibc/mod.rs b/src/unix/linux_like/linux/uclibc/mod.rs -index 4afb98e95..67d5ba1b3 100644 +index 48b03e9ee..3df2f7b3c 100644 --- a/src/unix/linux_like/linux/uclibc/mod.rs +++ b/src/unix/linux_like/linux/uclibc/mod.rs @@ -107,6 +107,68 @@ struct siginfo_si_value { } } -+cfg_if! { -+ if #[cfg(libc_union)] { -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ struct sifields_sigchld { -+ si_pid: ::pid_t, -+ si_uid: ::uid_t, -+ si_status: ::c_int, -+ si_utime: ::c_long, -+ si_stime: ::c_long, -+ } -+ impl ::Copy for sifields_sigchld {} -+ impl ::Clone for sifields_sigchld { -+ fn clone(&self) -> sifields_sigchld { -+ *self -+ } -+ } ++extern "C" { ++ pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; ++} ++ ++// Internal, for casts to access union fields ++#[repr(C)] ++struct sifields_sigchld { ++ si_pid: ::pid_t, ++ si_uid: ::uid_t, ++ si_status: ::c_int, ++ si_utime: ::c_long, ++ si_stime: ::c_long, ++} ++impl ::Copy for sifields_sigchld {} ++impl ::Clone for sifields_sigchld { ++ fn clone(&self) -> sifields_sigchld { ++ *self ++ } ++} + -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ union sifields { -+ _align_pointer: *mut ::c_void, -+ sigchld: sifields_sigchld, -+ } ++// Internal, for casts to access union fields ++#[repr(C)] ++union sifields { ++ _align_pointer: *mut ::c_void, ++ sigchld: sifields_sigchld, ++} + -+ // Internal, for casts to access union fields. Note that some variants -+ // of sifields start with a pointer, which makes the alignment of -+ // sifields vary on 32-bit and 64-bit architectures. -+ #[repr(C)] -+ struct siginfo_f { -+ _siginfo_base: [::c_int; 3], -+ sifields: sifields, -+ } ++// Internal, for casts to access union fields. Note that some variants ++// of sifields start with a pointer, which makes the alignment of ++// sifields vary on 32-bit and 64-bit architectures. ++#[repr(C)] ++struct siginfo_f { ++ _siginfo_base: [::c_int; 3], ++ sifields: sifields, ++} + -+ impl siginfo_t { -+ unsafe fn sifields(&self) -> &sifields { -+ &(*(self as *const siginfo_t as *const siginfo_f)).sifields -+ } ++impl siginfo_t { ++ unsafe fn sifields(&self) -> &sifields { ++ &(*(self as *const siginfo_t as *const siginfo_f)).sifields ++ } + -+ pub unsafe fn si_pid(&self) -> ::pid_t { -+ self.sifields().sigchld.si_pid -+ } ++ pub unsafe fn si_pid(&self) -> ::pid_t { ++ self.sifields().sigchld.si_pid ++ } + -+ pub unsafe fn si_uid(&self) -> ::uid_t { -+ self.sifields().sigchld.si_uid -+ } ++ pub unsafe fn si_uid(&self) -> ::uid_t { ++ self.sifields().sigchld.si_uid ++ } + -+ pub unsafe fn si_status(&self) -> ::c_int { -+ self.sifields().sigchld.si_status -+ } ++ pub unsafe fn si_status(&self) -> ::c_int { ++ self.sifields().sigchld.si_status ++ } + -+ pub unsafe fn si_utime(&self) -> ::c_long { -+ self.sifields().sigchld.si_utime -+ } ++ pub unsafe fn si_utime(&self) -> ::c_long { ++ self.sifields().sigchld.si_utime ++ } + -+ pub unsafe fn si_stime(&self) -> ::c_long { -+ self.sifields().sigchld.si_stime -+ } -+ } ++ pub unsafe fn si_stime(&self) -> ::c_long { ++ self.sifields().sigchld.si_stime + } +} + diff --git a/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabihf.diff b/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabihf.diff index 92ed8bb..87a1e0e 100644 --- a/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabihf.diff +++ b/docker/test-base/patches/libc+armv7-unknown-linux-uclibceabihf.diff @@ -1,70 +1,70 @@ diff --git a/src/unix/linux_like/linux/uclibc/mod.rs b/src/unix/linux_like/linux/uclibc/mod.rs -index 4afb98e95..67d5ba1b3 100644 +index 48b03e9ee..3df2f7b3c 100644 --- a/src/unix/linux_like/linux/uclibc/mod.rs +++ b/src/unix/linux_like/linux/uclibc/mod.rs @@ -107,6 +107,68 @@ struct siginfo_si_value { } } -+cfg_if! { -+ if #[cfg(libc_union)] { -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ struct sifields_sigchld { -+ si_pid: ::pid_t, -+ si_uid: ::uid_t, -+ si_status: ::c_int, -+ si_utime: ::c_long, -+ si_stime: ::c_long, -+ } -+ impl ::Copy for sifields_sigchld {} -+ impl ::Clone for sifields_sigchld { -+ fn clone(&self) -> sifields_sigchld { -+ *self -+ } -+ } ++extern "C" { ++ pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; ++} ++ ++// Internal, for casts to access union fields ++#[repr(C)] ++struct sifields_sigchld { ++ si_pid: ::pid_t, ++ si_uid: ::uid_t, ++ si_status: ::c_int, ++ si_utime: ::c_long, ++ si_stime: ::c_long, ++} ++impl ::Copy for sifields_sigchld {} ++impl ::Clone for sifields_sigchld { ++ fn clone(&self) -> sifields_sigchld { ++ *self ++ } ++} + -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ union sifields { -+ _align_pointer: *mut ::c_void, -+ sigchld: sifields_sigchld, -+ } ++// Internal, for casts to access union fields ++#[repr(C)] ++union sifields { ++ _align_pointer: *mut ::c_void, ++ sigchld: sifields_sigchld, ++} + -+ // Internal, for casts to access union fields. Note that some variants -+ // of sifields start with a pointer, which makes the alignment of -+ // sifields vary on 32-bit and 64-bit architectures. -+ #[repr(C)] -+ struct siginfo_f { -+ _siginfo_base: [::c_int; 3], -+ sifields: sifields, -+ } ++// Internal, for casts to access union fields. Note that some variants ++// of sifields start with a pointer, which makes the alignment of ++// sifields vary on 32-bit and 64-bit architectures. ++#[repr(C)] ++struct siginfo_f { ++ _siginfo_base: [::c_int; 3], ++ sifields: sifields, ++} + -+ impl siginfo_t { -+ unsafe fn sifields(&self) -> &sifields { -+ &(*(self as *const siginfo_t as *const siginfo_f)).sifields -+ } ++impl siginfo_t { ++ unsafe fn sifields(&self) -> &sifields { ++ &(*(self as *const siginfo_t as *const siginfo_f)).sifields ++ } + -+ pub unsafe fn si_pid(&self) -> ::pid_t { -+ self.sifields().sigchld.si_pid -+ } ++ pub unsafe fn si_pid(&self) -> ::pid_t { ++ self.sifields().sigchld.si_pid ++ } + -+ pub unsafe fn si_uid(&self) -> ::uid_t { -+ self.sifields().sigchld.si_uid -+ } ++ pub unsafe fn si_uid(&self) -> ::uid_t { ++ self.sifields().sigchld.si_uid ++ } + -+ pub unsafe fn si_status(&self) -> ::c_int { -+ self.sifields().sigchld.si_status -+ } ++ pub unsafe fn si_status(&self) -> ::c_int { ++ self.sifields().sigchld.si_status ++ } + -+ pub unsafe fn si_utime(&self) -> ::c_long { -+ self.sifields().sigchld.si_utime -+ } ++ pub unsafe fn si_utime(&self) -> ::c_long { ++ self.sifields().sigchld.si_utime ++ } + -+ pub unsafe fn si_stime(&self) -> ::c_long { -+ self.sifields().sigchld.si_stime -+ } -+ } ++ pub unsafe fn si_stime(&self) -> ::c_long { ++ self.sifields().sigchld.si_stime + } +} + diff --git a/docker/test-base/patches/libc+mips-unknown-linux-uclibc.diff b/docker/test-base/patches/libc+mips-unknown-linux-uclibc.diff index 92ed8bb..87a1e0e 100644 --- a/docker/test-base/patches/libc+mips-unknown-linux-uclibc.diff +++ b/docker/test-base/patches/libc+mips-unknown-linux-uclibc.diff @@ -1,70 +1,70 @@ diff --git a/src/unix/linux_like/linux/uclibc/mod.rs b/src/unix/linux_like/linux/uclibc/mod.rs -index 4afb98e95..67d5ba1b3 100644 +index 48b03e9ee..3df2f7b3c 100644 --- a/src/unix/linux_like/linux/uclibc/mod.rs +++ b/src/unix/linux_like/linux/uclibc/mod.rs @@ -107,6 +107,68 @@ struct siginfo_si_value { } } -+cfg_if! { -+ if #[cfg(libc_union)] { -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ struct sifields_sigchld { -+ si_pid: ::pid_t, -+ si_uid: ::uid_t, -+ si_status: ::c_int, -+ si_utime: ::c_long, -+ si_stime: ::c_long, -+ } -+ impl ::Copy for sifields_sigchld {} -+ impl ::Clone for sifields_sigchld { -+ fn clone(&self) -> sifields_sigchld { -+ *self -+ } -+ } ++extern "C" { ++ pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; ++} ++ ++// Internal, for casts to access union fields ++#[repr(C)] ++struct sifields_sigchld { ++ si_pid: ::pid_t, ++ si_uid: ::uid_t, ++ si_status: ::c_int, ++ si_utime: ::c_long, ++ si_stime: ::c_long, ++} ++impl ::Copy for sifields_sigchld {} ++impl ::Clone for sifields_sigchld { ++ fn clone(&self) -> sifields_sigchld { ++ *self ++ } ++} + -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ union sifields { -+ _align_pointer: *mut ::c_void, -+ sigchld: sifields_sigchld, -+ } ++// Internal, for casts to access union fields ++#[repr(C)] ++union sifields { ++ _align_pointer: *mut ::c_void, ++ sigchld: sifields_sigchld, ++} + -+ // Internal, for casts to access union fields. Note that some variants -+ // of sifields start with a pointer, which makes the alignment of -+ // sifields vary on 32-bit and 64-bit architectures. -+ #[repr(C)] -+ struct siginfo_f { -+ _siginfo_base: [::c_int; 3], -+ sifields: sifields, -+ } ++// Internal, for casts to access union fields. Note that some variants ++// of sifields start with a pointer, which makes the alignment of ++// sifields vary on 32-bit and 64-bit architectures. ++#[repr(C)] ++struct siginfo_f { ++ _siginfo_base: [::c_int; 3], ++ sifields: sifields, ++} + -+ impl siginfo_t { -+ unsafe fn sifields(&self) -> &sifields { -+ &(*(self as *const siginfo_t as *const siginfo_f)).sifields -+ } ++impl siginfo_t { ++ unsafe fn sifields(&self) -> &sifields { ++ &(*(self as *const siginfo_t as *const siginfo_f)).sifields ++ } + -+ pub unsafe fn si_pid(&self) -> ::pid_t { -+ self.sifields().sigchld.si_pid -+ } ++ pub unsafe fn si_pid(&self) -> ::pid_t { ++ self.sifields().sigchld.si_pid ++ } + -+ pub unsafe fn si_uid(&self) -> ::uid_t { -+ self.sifields().sigchld.si_uid -+ } ++ pub unsafe fn si_uid(&self) -> ::uid_t { ++ self.sifields().sigchld.si_uid ++ } + -+ pub unsafe fn si_status(&self) -> ::c_int { -+ self.sifields().sigchld.si_status -+ } ++ pub unsafe fn si_status(&self) -> ::c_int { ++ self.sifields().sigchld.si_status ++ } + -+ pub unsafe fn si_utime(&self) -> ::c_long { -+ self.sifields().sigchld.si_utime -+ } ++ pub unsafe fn si_utime(&self) -> ::c_long { ++ self.sifields().sigchld.si_utime ++ } + -+ pub unsafe fn si_stime(&self) -> ::c_long { -+ self.sifields().sigchld.si_stime -+ } -+ } ++ pub unsafe fn si_stime(&self) -> ::c_long { ++ self.sifields().sigchld.si_stime + } +} + diff --git a/docker/test-base/patches/libc+mipsel-unknown-linux-uclibc.diff b/docker/test-base/patches/libc+mipsel-unknown-linux-uclibc.diff index 92ed8bb..87a1e0e 100644 --- a/docker/test-base/patches/libc+mipsel-unknown-linux-uclibc.diff +++ b/docker/test-base/patches/libc+mipsel-unknown-linux-uclibc.diff @@ -1,70 +1,70 @@ diff --git a/src/unix/linux_like/linux/uclibc/mod.rs b/src/unix/linux_like/linux/uclibc/mod.rs -index 4afb98e95..67d5ba1b3 100644 +index 48b03e9ee..3df2f7b3c 100644 --- a/src/unix/linux_like/linux/uclibc/mod.rs +++ b/src/unix/linux_like/linux/uclibc/mod.rs @@ -107,6 +107,68 @@ struct siginfo_si_value { } } -+cfg_if! { -+ if #[cfg(libc_union)] { -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ struct sifields_sigchld { -+ si_pid: ::pid_t, -+ si_uid: ::uid_t, -+ si_status: ::c_int, -+ si_utime: ::c_long, -+ si_stime: ::c_long, -+ } -+ impl ::Copy for sifields_sigchld {} -+ impl ::Clone for sifields_sigchld { -+ fn clone(&self) -> sifields_sigchld { -+ *self -+ } -+ } ++extern "C" { ++ pub fn getauxval(type_: ::c_ulong) -> ::c_ulong; ++} ++ ++// Internal, for casts to access union fields ++#[repr(C)] ++struct sifields_sigchld { ++ si_pid: ::pid_t, ++ si_uid: ::uid_t, ++ si_status: ::c_int, ++ si_utime: ::c_long, ++ si_stime: ::c_long, ++} ++impl ::Copy for sifields_sigchld {} ++impl ::Clone for sifields_sigchld { ++ fn clone(&self) -> sifields_sigchld { ++ *self ++ } ++} + -+ // Internal, for casts to access union fields -+ #[repr(C)] -+ union sifields { -+ _align_pointer: *mut ::c_void, -+ sigchld: sifields_sigchld, -+ } ++// Internal, for casts to access union fields ++#[repr(C)] ++union sifields { ++ _align_pointer: *mut ::c_void, ++ sigchld: sifields_sigchld, ++} + -+ // Internal, for casts to access union fields. Note that some variants -+ // of sifields start with a pointer, which makes the alignment of -+ // sifields vary on 32-bit and 64-bit architectures. -+ #[repr(C)] -+ struct siginfo_f { -+ _siginfo_base: [::c_int; 3], -+ sifields: sifields, -+ } ++// Internal, for casts to access union fields. Note that some variants ++// of sifields start with a pointer, which makes the alignment of ++// sifields vary on 32-bit and 64-bit architectures. ++#[repr(C)] ++struct siginfo_f { ++ _siginfo_base: [::c_int; 3], ++ sifields: sifields, ++} + -+ impl siginfo_t { -+ unsafe fn sifields(&self) -> &sifields { -+ &(*(self as *const siginfo_t as *const siginfo_f)).sifields -+ } ++impl siginfo_t { ++ unsafe fn sifields(&self) -> &sifields { ++ &(*(self as *const siginfo_t as *const siginfo_f)).sifields ++ } + -+ pub unsafe fn si_pid(&self) -> ::pid_t { -+ self.sifields().sigchld.si_pid -+ } ++ pub unsafe fn si_pid(&self) -> ::pid_t { ++ self.sifields().sigchld.si_pid ++ } + -+ pub unsafe fn si_uid(&self) -> ::uid_t { -+ self.sifields().sigchld.si_uid -+ } ++ pub unsafe fn si_uid(&self) -> ::uid_t { ++ self.sifields().sigchld.si_uid ++ } + -+ pub unsafe fn si_status(&self) -> ::c_int { -+ self.sifields().sigchld.si_status -+ } ++ pub unsafe fn si_status(&self) -> ::c_int { ++ self.sifields().sigchld.si_status ++ } + -+ pub unsafe fn si_utime(&self) -> ::c_long { -+ self.sifields().sigchld.si_utime -+ } ++ pub unsafe fn si_utime(&self) -> ::c_long { ++ self.sifields().sigchld.si_utime ++ } + -+ pub unsafe fn si_stime(&self) -> ::c_long { -+ self.sifields().sigchld.si_stime -+ } -+ } ++ pub unsafe fn si_stime(&self) -> ::c_long { ++ self.sifields().sigchld.si_stime + } +} + diff --git a/docker/test-base/patches/libc+x86_64-unknown-dragonfly.diff b/docker/test-base/patches/libc+x86_64-unknown-dragonfly.diff new file mode 100644 index 0000000..7a627db --- /dev/null +++ b/docker/test-base/patches/libc+x86_64-unknown-dragonfly.diff @@ -0,0 +1,51 @@ +diff --git a/src/unix/bsd/freebsdlike/freebsd/mod.rs b/src/unix/bsd/freebsdlike/freebsd/mod.rs +index 78314084c..195c6cb3e 100644 +--- a/src/unix/bsd/freebsdlike/freebsd/mod.rs ++++ b/src/unix/bsd/freebsdlike/freebsd/mod.rs +@@ -3875,11 +3875,6 @@ fn clone(&self) -> dot3Vendors { + // for use with fspacectl + pub const SPACECTL_DEALLOC: ::c_int = 1; + +-// For getrandom() +-pub const GRND_NONBLOCK: ::c_uint = 0x1; +-pub const GRND_RANDOM: ::c_uint = 0x2; +-pub const GRND_INSECURE: ::c_uint = 0x4; +- + // For realhostname* api + pub const HOSTNAME_FOUND: ::c_int = 0; + pub const HOSTNAME_INCORRECTNAME: ::c_int = 1; +@@ -5393,8 +5388,6 @@ pub fn shm_rename( + + pub fn fdatasync(fd: ::c_int) -> ::c_int; + +- pub fn getrandom(buf: *mut ::c_void, buflen: ::size_t, flags: ::c_uint) -> ::ssize_t; +- pub fn getentropy(buf: *mut ::c_void, buflen: ::size_t) -> ::c_int; + pub fn elf_aux_info(aux: ::c_int, buf: *mut ::c_void, buflen: ::c_int) -> ::c_int; + pub fn setproctitle_fast(fmt: *const ::c_char, ...); + pub fn timingsafe_bcmp(a: *const ::c_void, b: *const ::c_void, len: ::size_t) -> ::c_int; +diff --git a/src/unix/bsd/freebsdlike/mod.rs b/src/unix/bsd/freebsdlike/mod.rs +index 00a944e42..9b555e42e 100644 +--- a/src/unix/bsd/freebsdlike/mod.rs ++++ b/src/unix/bsd/freebsdlike/mod.rs +@@ -1456,6 +1456,11 @@ fn hash(&self, state: &mut H) { + pub const RB_MUTE: ::c_int = 0x10000; + pub const RB_SELFTEST: ::c_int = 0x20000; + ++// For getrandom() ++pub const GRND_NONBLOCK: ::c_uint = 0x1; ++pub const GRND_RANDOM: ::c_uint = 0x2; ++pub const GRND_INSECURE: ::c_uint = 0x4; ++ + safe_f! { + pub {const} fn WIFCONTINUED(status: ::c_int) -> bool { + status == 0x13 +@@ -1829,6 +1834,9 @@ pub fn mq_timedsend( + abs_timeout: *const ::timespec, + ) -> ::c_int; + pub fn mq_unlink(name: *const ::c_char) -> ::c_int; ++ ++ pub fn getrandom(buf: *mut ::c_void, buflen: ::size_t, flags: ::c_uint) -> ::ssize_t; ++ pub fn getentropy(buf: *mut ::c_void, buflen: ::size_t) -> ::c_int; + } + + #[link(name = "util")] diff --git a/docker/test-base/patches/std+armv5te-unknown-linux-uclibceabi.diff b/docker/test-base/patches/std+armv5te-unknown-linux-uclibceabi.diff new file mode 100644 index 0000000..c2d9bbc --- /dev/null +++ b/docker/test-base/patches/std+armv5te-unknown-linux-uclibceabi.diff @@ -0,0 +1,14 @@ +diff --git a/src/sys/pal/unix/stack_overflow.rs b/src/sys/pal/unix/stack_overflow.rs +index 78a5990..1b875e5 100644 +--- a/src/sys/pal/unix/stack_overflow.rs ++++ b/src/sys/pal/unix/stack_overflow.rs +@@ -213,6 +213,9 @@ pub unsafe fn drop_handler(data: *mut libc::c_void) { + fn sigstack_size() -> usize { + // FIXME: reuse const from libc when available? + const AT_MINSIGSTKSZ: crate::ffi::c_ulong = 51; ++ #[cfg(target_env = "uclibc")] ++ let dynamic_sigstksz: crate::ffi::c_ulong = 0; ++ #[cfg(not(target_env = "uclibc"))] + let dynamic_sigstksz = unsafe { libc::getauxval(AT_MINSIGSTKSZ) }; + // If getauxval couldn't find the entry, it returns 0, + // so take the higher of the "constant" and auxval. diff --git a/docker/test-base/patches/std+armv7-unknown-linux-uclibceabi.diff b/docker/test-base/patches/std+armv7-unknown-linux-uclibceabi.diff new file mode 100644 index 0000000..c2d9bbc --- /dev/null +++ b/docker/test-base/patches/std+armv7-unknown-linux-uclibceabi.diff @@ -0,0 +1,14 @@ +diff --git a/src/sys/pal/unix/stack_overflow.rs b/src/sys/pal/unix/stack_overflow.rs +index 78a5990..1b875e5 100644 +--- a/src/sys/pal/unix/stack_overflow.rs ++++ b/src/sys/pal/unix/stack_overflow.rs +@@ -213,6 +213,9 @@ pub unsafe fn drop_handler(data: *mut libc::c_void) { + fn sigstack_size() -> usize { + // FIXME: reuse const from libc when available? + const AT_MINSIGSTKSZ: crate::ffi::c_ulong = 51; ++ #[cfg(target_env = "uclibc")] ++ let dynamic_sigstksz: crate::ffi::c_ulong = 0; ++ #[cfg(not(target_env = "uclibc"))] + let dynamic_sigstksz = unsafe { libc::getauxval(AT_MINSIGSTKSZ) }; + // If getauxval couldn't find the entry, it returns 0, + // so take the higher of the "constant" and auxval. diff --git a/docker/test-base/patches/std+armv7-unknown-linux-uclibceabihf.diff b/docker/test-base/patches/std+armv7-unknown-linux-uclibceabihf.diff new file mode 100644 index 0000000..c2d9bbc --- /dev/null +++ b/docker/test-base/patches/std+armv7-unknown-linux-uclibceabihf.diff @@ -0,0 +1,14 @@ +diff --git a/src/sys/pal/unix/stack_overflow.rs b/src/sys/pal/unix/stack_overflow.rs +index 78a5990..1b875e5 100644 +--- a/src/sys/pal/unix/stack_overflow.rs ++++ b/src/sys/pal/unix/stack_overflow.rs +@@ -213,6 +213,9 @@ pub unsafe fn drop_handler(data: *mut libc::c_void) { + fn sigstack_size() -> usize { + // FIXME: reuse const from libc when available? + const AT_MINSIGSTKSZ: crate::ffi::c_ulong = 51; ++ #[cfg(target_env = "uclibc")] ++ let dynamic_sigstksz: crate::ffi::c_ulong = 0; ++ #[cfg(not(target_env = "uclibc"))] + let dynamic_sigstksz = unsafe { libc::getauxval(AT_MINSIGSTKSZ) }; + // If getauxval couldn't find the entry, it returns 0, + // so take the higher of the "constant" and auxval. diff --git a/docker/test-base/patches/std+mips-unknown-linux-uclibc.diff b/docker/test-base/patches/std+mips-unknown-linux-uclibc.diff new file mode 100644 index 0000000..c2d9bbc --- /dev/null +++ b/docker/test-base/patches/std+mips-unknown-linux-uclibc.diff @@ -0,0 +1,14 @@ +diff --git a/src/sys/pal/unix/stack_overflow.rs b/src/sys/pal/unix/stack_overflow.rs +index 78a5990..1b875e5 100644 +--- a/src/sys/pal/unix/stack_overflow.rs ++++ b/src/sys/pal/unix/stack_overflow.rs +@@ -213,6 +213,9 @@ pub unsafe fn drop_handler(data: *mut libc::c_void) { + fn sigstack_size() -> usize { + // FIXME: reuse const from libc when available? + const AT_MINSIGSTKSZ: crate::ffi::c_ulong = 51; ++ #[cfg(target_env = "uclibc")] ++ let dynamic_sigstksz: crate::ffi::c_ulong = 0; ++ #[cfg(not(target_env = "uclibc"))] + let dynamic_sigstksz = unsafe { libc::getauxval(AT_MINSIGSTKSZ) }; + // If getauxval couldn't find the entry, it returns 0, + // so take the higher of the "constant" and auxval. diff --git a/docker/test-base/patches/std+mipsel-unknown-linux-uclibc.diff b/docker/test-base/patches/std+mipsel-unknown-linux-uclibc.diff new file mode 100644 index 0000000..c2d9bbc --- /dev/null +++ b/docker/test-base/patches/std+mipsel-unknown-linux-uclibc.diff @@ -0,0 +1,14 @@ +diff --git a/src/sys/pal/unix/stack_overflow.rs b/src/sys/pal/unix/stack_overflow.rs +index 78a5990..1b875e5 100644 +--- a/src/sys/pal/unix/stack_overflow.rs ++++ b/src/sys/pal/unix/stack_overflow.rs +@@ -213,6 +213,9 @@ pub unsafe fn drop_handler(data: *mut libc::c_void) { + fn sigstack_size() -> usize { + // FIXME: reuse const from libc when available? + const AT_MINSIGSTKSZ: crate::ffi::c_ulong = 51; ++ #[cfg(target_env = "uclibc")] ++ let dynamic_sigstksz: crate::ffi::c_ulong = 0; ++ #[cfg(not(target_env = "uclibc"))] + let dynamic_sigstksz = unsafe { libc::getauxval(AT_MINSIGSTKSZ) }; + // If getauxval couldn't find the entry, it returns 0, + // so take the higher of the "constant" and auxval. diff --git a/platform-support-status-tier3.md b/platform-support-status-tier3.md index 709c863..19e3812 100644 --- a/platform-support-status-tier3.md +++ b/platform-support-status-tier3.md @@ -75,7 +75,7 @@ See [platform-support-status.md](platform-support-status.md) for Tier 1 & Tier 2 - [ ] i686-win7-windows-msvc - [ ] i686-wrs-vxworks - [ ] loongarch64-unknown-linux-musl -- [ ] m68k-unknown-linux-gnu +- [x] m68k-unknown-linux-gnu - [x] mips-unknown-linux-gnu - [x] mips-unknown-linux-musl - [x] mips-unknown-linux-uclibc diff --git a/tools/target-list-shared.sh b/tools/target-list-shared.sh index 7863f76..c883b24 100644 --- a/tools/target-list-shared.sh +++ b/tools/target-list-shared.sh @@ -21,7 +21,7 @@ linux_gnu_targets=( i586-unknown-linux-gnu i686-unknown-linux-gnu loongarch64-unknown-linux-gnu - # m68k-unknown-linux-gnu # tier3, build fail: https://github.com/rust-lang/rust/issues/89498 + m68k-unknown-linux-gnu # tier3, build fail: https://github.com/rust-lang/rust/issues/89498 mips-unknown-linux-gnu # tier3 mips64-unknown-linux-gnuabi64 # tier3 mips64el-unknown-linux-gnuabi64 # tier3