add basic support for android targets

Author: Lander Brandt

src/helpers.rs

@@ -437,6 +437,20 @@ 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 `target_os`. It panics showing a message with the `name` of the foreign function
+    /// if this is not the case.
+    fn assert_target_os_is_unix(&self, name: &str) {
+        assert!(
+            matches!(
+                self.eval_context_ref().tcx.sess.target.os.as_str(),
+                "linux" | "macos" | "android"
+            ),
+            "`{}` is only available for the UNIX target family",
+            name,
+        );
+    }
+
     /// Get last error variable as a place, lazily allocating thread-local storage for it if
     /// necessary.
     fn last_error_place(&mut self) -> InterpResult<'tcx, MPlaceTy<'tcx, Tag>> {

src/machine.rs

@@ -253,6 +253,23 @@ impl MemoryExtra {
                 this.write_scalar(Scalar::from_u8(0), &place.into())?;
                 Self::add_extern_static(this, "_tls_used", place.ptr);
             }
+            "android" =>
+                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)?
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "hardcoded `extern static` symbol {} has no dlsym handler",
+                                symbol_name
+                            )
+                        });
+                    let (provenance, offset) =
+                        this.memory.create_fn_alloc(FnVal::Other(dlsym)).into_parts();
+                    let ptr = Pointer::new(Some(provenance), offset);
+                    let place = this.allocate(layout, MiriMemoryKind::ExternStatic.into())?;
+                    this.write_pointer(ptr, &place.into())?;
+                    Self::add_extern_static(this, symbol_name, place.ptr);
+                },
             _ => {} // No "extern statics" supported on this target
         }
         Ok(())

src/shims/dlsym.rs

@@ -18,7 +18,8 @@ impl Dlsym {
     pub fn from_str(name: &[u8], target_os: &str) -> InterpResult<'static, Option<Dlsym>> {
         let name = &*String::from_utf8_lossy(name);
         Ok(match target_os {
-            "linux" | "macos" => posix::Dlsym::from_str(name, target_os)?.map(Dlsym::Posix),
+            "linux" | "macos" | "android" =>
+                posix::Dlsym::from_str(name, target_os)?.map(Dlsym::Posix),
             "windows" => windows::Dlsym::from_str(name)?.map(Dlsym::Windows),
             os => bug!("dlsym not implemented for target_os {}", os),
         })

src/shims/env.rs

@@ -114,11 +114,7 @@ impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mi
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     fn getenv(&mut self, name_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, Pointer<Option<Tag>>> {
         let this = self.eval_context_mut();
-        let target_os = &this.tcx.sess.target.os;
-        assert!(
-            target_os == "linux" || target_os == "macos",
-            "`getenv` is only available for the UNIX target family"
-        );
+        this.assert_target_os_is_unix("getenv");
 
         let name_ptr = this.read_pointer(name_op)?;
         let name = this.read_os_str_from_c_str(name_ptr)?;
@@ -212,11 +208,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         value_op: &OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, i32> {
         let mut this = self.eval_context_mut();
-        let target_os = &this.tcx.sess.target.os;
-        assert!(
-            target_os == "linux" || target_os == "macos",
-            "`setenv` is only available for the UNIX target family"
-        );
+        this.assert_target_os_is_unix("setenv");
 
         let name_ptr = this.read_pointer(name_op)?;
         let value_ptr = this.read_pointer(value_op)?;
@@ -286,11 +278,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     fn unsetenv(&mut self, name_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
-        let target_os = &this.tcx.sess.target.os;
-        assert!(
-            target_os == "linux" || target_os == "macos",
-            "`unsetenv` is only available for the UNIX target family"
-        );
+        this.assert_target_os_is_unix("unsetenv");
 
         let name_ptr = this.read_pointer(name_op)?;
         let mut success = None;
@@ -320,11 +308,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         size_op: &OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, Pointer<Option<Tag>>> {
         let this = self.eval_context_mut();
-        let target_os = &this.tcx.sess.target.os;
-        assert!(
-            target_os == "linux" || target_os == "macos",
-            "`getcwd` is only available for the UNIX target family"
-        );
+        this.assert_target_os_is_unix("getcwd");
 
         let buf = this.read_pointer(&buf_op)?;
         let size = this.read_scalar(&size_op)?.to_machine_usize(&*this.tcx)?;
@@ -379,11 +363,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     fn chdir(&mut self, path_op: &OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
-        let target_os = &this.tcx.sess.target.os;
-        assert!(
-            target_os == "linux" || target_os == "macos",
-            "`getcwd` is only available for the UNIX target family"
-        );
+        this.assert_target_os_is_unix("chdir");
 
         let path = this.read_path_from_c_str(this.read_pointer(path_op)?)?;
 

src/shims/foreign_items.rs

@@ -687,7 +687,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
             // Platform-specific shims
             _ => match this.tcx.sess.target.os.as_str() {
-                "linux" | "macos" => return shims::posix::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
+                "linux" | "macos" | "android" => return shims::posix::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
                 "windows" => return shims::windows::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
                 target => throw_unsup_format!("the target `{}` is not supported", target),
             }

src/shims/posix/android/dlsym.rs

@@ -0,0 +1,50 @@
+use helpers::check_arg_count;
+use log::trace;
+use rustc_middle::mir;
+
+use crate::*;
+
+#[derive(Debug, Copy, Clone)]
+#[allow(non_camel_case_types)]
+pub enum Dlsym {
+    signal,
+}
+
+impl Dlsym {
+    // Returns an error for unsupported symbols, and None if this symbol
+    // should become a NULL pointer (pretend it does not exist).
+    pub fn from_str(name: &str) -> InterpResult<'static, Option<Dlsym>> {
+        Ok(match &*name {
+            "__pthread_get_minstack" => None,
+            "getrandom" => None, // std falls back to syscall(SYS_getrandom, ...) when this is NULL.
+            "statx" => None,     // std falls back to syscall(SYS_statx, ...) when this is NULL.
+            "signal" | "bsd_signal" => Some(Dlsym::signal), // these have the same signature/implementation
+            _ => throw_unsup_format!("unsupported Android dlsym: {}", name),
+        })
+    }
+}
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn call_dlsym(
+        &mut self,
+        dlsym: Dlsym,
+        args: &[OpTy<'tcx, Tag>],
+        ret: Option<(&PlaceTy<'tcx, Tag>, mir::BasicBlock)>,
+    ) -> InterpResult<'tcx> {
+        let this = self.eval_context_mut();
+        let (dest, ret) = ret.expect("we don't support any diverging dlsym");
+        assert!(this.tcx.sess.target.os == "android");
+
+        match dlsym {
+            Dlsym::signal => {
+                let &[ref _sig, ref _func] = check_arg_count(args)?;
+                this.write_null(dest)?;
+            }
+        }
+
+        trace!("{:?}", this.dump_place(**dest));
+        this.go_to_block(ret);
+        Ok(())
+    }
+}

src/shims/posix/android/foreign_items.rs

@@ -0,0 +1,28 @@
+use rustc_middle::mir;
+use rustc_span::Symbol;
+use rustc_target::spec::abi::Abi;
+
+use crate::*;
+use shims::foreign_items::EmulateByNameResult;
+
+impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn emulate_foreign_item_by_name(
+        &mut self,
+        link_name: Symbol,
+        abi: Abi,
+        args: &[OpTy<'tcx, Tag>],
+        dest: &PlaceTy<'tcx, Tag>,
+        ret: mir::BasicBlock,
+    ) -> InterpResult<'tcx, EmulateByNameResult<'mir, 'tcx>> {
+        let this = self.eval_context_mut();
+
+        match &*link_name.as_str() {
+            _ => {
+                // By default we piggyback off the items emulated for Linux. For now this functions
+                // serves to make adding android-specific syscalls easy
+                return shims::posix::linux::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret);
+            }
+        }
+    }
+}

src/shims/posix/android/mod.rs

@@ -0,0 +1,2 @@
+pub mod dlsym;
+pub mod foreign_items;

src/shims/posix/dlsym.rs

@@ -2,13 +2,15 @@ use rustc_middle::mir;
 use rustc_target::spec::abi::Abi;
 
 use crate::*;
+use shims::posix::android::dlsym as android;
 use shims::posix::linux::dlsym as linux;
 use shims::posix::macos::dlsym as macos;
 
 #[derive(Debug, Copy, Clone)]
 pub enum Dlsym {
     Linux(linux::Dlsym),
     MacOs(macos::Dlsym),
+    Android(android::Dlsym),
 }
 
 impl Dlsym {
@@ -18,6 +20,7 @@ impl Dlsym {
         Ok(match target_os {
             "linux" => linux::Dlsym::from_str(name)?.map(Dlsym::Linux),
             "macos" => macos::Dlsym::from_str(name)?.map(Dlsym::MacOs),
+            "android" => android::Dlsym::from_str(name)?.map(Dlsym::Android),
             _ => unreachable!(),
         })
     }
@@ -39,6 +42,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         match dlsym {
             Dlsym::Linux(dlsym) => linux::EvalContextExt::call_dlsym(this, dlsym, args, ret),
             Dlsym::MacOs(dlsym) => macos::EvalContextExt::call_dlsym(this, dlsym, args, ret),
+            Dlsym::Android(dlsym) => android::EvalContextExt::call_dlsym(this, dlsym, args, ret),
         }
     }
 }

src/shims/posix/foreign_items.rs

@@ -465,6 +465,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 match this.tcx.sess.target.os.as_str() {
                     "linux" => return shims::posix::linux::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
                     "macos" => return shims::posix::macos::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
+                    "android" => return shims::posix::android::foreign_items::EvalContextExt::emulate_foreign_item_by_name(this, link_name, abi, args, dest, ret),
                     _ => unreachable!(),
                 }
             }

src/shims/posix/mod.rs

@@ -5,6 +5,7 @@ mod fs;
 mod sync;
 mod thread;
 
+mod android;
 mod linux;
 mod macos;