fix issues with tests on Android

Author: Lander Brandt

ci.sh

@@ -21,6 +21,7 @@ function run_tests {
   fi
 
   ./miri test --locked
+
   if [ -z "${MIRI_TEST_TARGET+exists}" ]; then
     # Only for host architecture: tests with optimizations (`-O` is what cargo passes, but crank MIR
     # optimizations up all the way).
@@ -48,6 +49,7 @@ case $HOST_TARGET in
     MIRI_TEST_TARGET=i686-unknown-linux-gnu run_tests
     MIRI_TEST_TARGET=aarch64-apple-darwin run_tests
     MIRI_TEST_TARGET=i686-pc-windows-msvc run_tests
+    MIRI_TEST_TARGET=aarch64-linux-android run_tests
     ;;
   x86_64-apple-darwin)
     MIRI_TEST_TARGET=mips64-unknown-linux-gnuabi64 run_tests # big-endian architecture

src/helpers.rs

@@ -437,6 +437,17 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         )
     }
 
+    /// Helper function used inside the shims of foreign functions to assert that the target OS
+    /// is based on the Linux kernel. It panics showing a message with the `name` of the foreign function
+    /// if this is not the case.
+    fn assert_linux_based_target_os(&self, name: &str) {
+        assert!(
+            matches!(self.eval_context_ref().tcx.sess.target.os.as_str(), "linux" | "android"),
+            "`{}` is only available for supported Linux-based targets",
+            name,
+        )
+    }
+
     /// Helper function used inside the shims of foreign functions to assert that the target OS
     /// is part of the UNIX family. It panics showing a message with the `name` of the foreign function
     /// if this is not the case.

src/machine.rs

@@ -253,7 +253,23 @@ impl MemoryExtra {
                 this.write_scalar(Scalar::from_u8(0), &place.into())?;
                 Self::add_extern_static(this, "_tls_used", place.ptr);
             }
-            "android" =>
+            "android" => {
+                // "environ"
+                Self::add_extern_static(
+                    this,
+                    "environ",
+                    this.machine.env_vars.environ.unwrap().ptr,
+                );
+                // A couple zero-initialized pointer-sized extern statics.
+                // Most of them are for weak symbols, which we all set to null (indicating that the
+                // symbol is not supported, and triggering fallback code which ends up calling a
+                // syscall that we do support).
+                for name in &["__cxa_thread_atexit_impl", "getrandom", "statx"] {
+                    let layout = this.machine.layouts.usize;
+                    let place = this.allocate(layout, MiriMemoryKind::ExternStatic.into())?;
+                    this.write_scalar(Scalar::from_machine_usize(0, this), &place.into())?;
+                    Self::add_extern_static(this, name, place.ptr);
+                }
                 for symbol_name in &["signal", "bsd_signal"] {
                     let layout = this.machine.layouts.usize;
                     let dlsym = Dlsym::from_str(symbol_name.as_bytes(), &this.tcx.sess.target.os)?
@@ -268,8 +284,9 @@ impl MemoryExtra {
                     let place = this.allocate(layout, MiriMemoryKind::ExternStatic.into())?;
                     this.write_pointer(ptr, &place.into())?;
 
-                    Self::add_extern_static(this, symbol_name, place.ptr.into());
-                },
+                    Self::add_extern_static(this, symbol_name, place.ptr);
+                }
+            }
             _ => {} // No "extern statics" supported on this target
         }
         Ok(())

src/shims/env.rs

@@ -8,6 +8,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_target::abi::Size;
 
+use crate::helpers::target_os_is_unix;
 use crate::*;
 
 /// Check whether an operation that writes to a target buffer was successful.
@@ -57,7 +58,7 @@ impl<'tcx> EnvVars<'tcx> {
                 };
                 if forward {
                     let var_ptr = match target_os {
-                        "linux" | "macos" =>
+                        target if target_os_is_unix(target) =>
                             alloc_env_var_as_c_str(name.as_ref(), value.as_ref(), ecx)?,
                         "windows" => alloc_env_var_as_wide_str(name.as_ref(), value.as_ref(), ecx)?,
                         unsupported =>

src/shims/posix/android/foreign_items.rs

@@ -1,5 +1,6 @@
 use rustc_middle::mir;
 use rustc_span::Symbol;
+use rustc_target::abi::{Align, Size};
 use rustc_target::spec::abi::Abi;
 
 use crate::*;

src/shims/posix/foreign_items.rs

@@ -166,6 +166,23 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 }
                 this.write_null(dest)?;
             }
+            "memalign" => {
+                let &[ref align, ref size] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                let align = this.read_scalar(align)?.to_machine_usize(this)?;
+                let size = this.read_scalar(size)?.to_machine_usize(this)?;
+
+                // Align must be power of 2.
+                if !align.is_power_of_two() {
+                    throw_ub_format!("memalign: alignment must be a power of two, but is {}", align);
+                }
+
+                let ptr = this.memory.allocate(
+                    Size::from_bytes(size),
+                    Align::from_bytes(align).unwrap(),
+                    MiriMemoryKind::C.into(),
+                )?;
+                this.write_pointer(ptr, dest)?;
+            }
 
             // Dynamic symbol loading
             "dlsym" => {

src/shims/posix/fs.rs

@@ -937,7 +937,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     ) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
 
-        this.assert_target_os("linux", "statx");
+        this.assert_linux_based_target_os("statx");
 
         let statxbuf_ptr = this.read_pointer(statxbuf_op)?;
         let pathname_ptr = this.read_pointer(pathname_op)?;
@@ -1227,7 +1227,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn linux_readdir64(&mut self, dirp_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, Scalar<Tag>> {
         let this = self.eval_context_mut();
 
-        this.assert_target_os("linux", "readdir64");
+        this.assert_linux_based_target_os("readdir64");
 
         let dirp = this.read_scalar(dirp_op)?.to_machine_usize(this)?;
 

src/shims/posix/thread.rs

@@ -106,7 +106,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         _arg5: &OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
-        this.assert_target_os("linux", "prctl");
+        this.assert_linux_based_target_os("prctl");
 
         let option = this.read_scalar(option)?.to_i32()?;
         if option == this.eval_libc_i32("PR_SET_NAME")? {

src/shims/time.rs

@@ -20,7 +20,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     ) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
 
-        this.assert_target_os("linux", "clock_gettime");
+        this.assert_linux_based_target_os("clock_gettime");
         this.check_no_isolation("`clock_gettime`")?;
 
         let clk_id = this.read_scalar(clk_id_op)?.to_i32()?;

tests/compile-fail/concurrency/thread-spawn.rs

@@ -1,5 +1,6 @@
 // ignore-linux: Only Windows is not supported.
 // ignore-macos: Only Windows is not supported.
+// ignore-android: Only Windows is not supported.
 
 use std::thread;
 

tests/compiletest.rs

@@ -43,6 +43,8 @@ fn run_tests(mode: &str, path: &str, target: &str) {
     config.src_base = PathBuf::from(path);
     config.target = target.to_owned();
     config.target_rustcflags = Some(flags);
+    // Android targets require this to be set so that UI tests don't fail
+    config.adb_device_status = true;
     compiletest::run_tests(&config);
 }
 

tests/run-pass/wtf8.rs

@@ -1,5 +1,6 @@
 // ignore-linux: tests Windows-only APIs
 // ignore-macos: tests Windows-only APIs
+// ignore-android: tests Windows-only APIs
 
 use std::os::windows::ffi::{OsStrExt, OsStringExt};
 use std::ffi::{OsStr, OsString};