Remove untestable branches of statx and add helper function to deal with syscall arguments

Author: pvdrz

src/helpers.rs

@@ -1,5 +1,7 @@
 use std::{mem, iter};
 use std::ffi::OsStr;
+use std::convert::{ TryFrom, TryInto };
+use std::num::TryFromIntError;
 
 use syntax::source_map::DUMMY_SP;
 use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
@@ -480,6 +482,25 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         self.eval_context_mut().memory.write_bytes(scalar, bytes.iter().copied().chain(iter::once(0u8)))?;
         Ok(true)
     }
+
+    // Converts an operand with a machine `isize` into the desired integer type using `TryInto`.
+    // This function is useful when reading syscall related operands which are delivered as pointer
+    // sized operands.
+    fn try_from_ptr_sized_operand<T: TryFrom<i64, Error=TryFromIntError>>(
+        &mut self,
+        operand: OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, T> {
+        let this = self.eval_context_mut();
+
+        this.read_scalar(operand)?
+            .to_machine_isize(&*this.tcx)?
+            .try_into()
+            .map_err(|e| err_unsup_format!(
+                "Failed to convert pointer sized operand to integer: {}",
+                e
+            ).into())
+    }
+
 }
 
 #[cfg(target_os = "unix")]
@@ -550,3 +571,4 @@ pub fn immty_from_uint_checked<'tcx>(
     }
     Ok(ImmTy::from_uint(int, layout))
 }
+

src/shims/fs.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use std::convert::TryFrom;
+use std::convert::{TryInto, TryFrom};
 use std::fs::{remove_file, File, OpenOptions};
 use std::io::{Read, Write};
 use std::path::PathBuf;
@@ -304,19 +304,21 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         };
 
         let pathname: PathBuf = this.read_os_str_from_c_str(pathname_scalar)?.into();
-        let flags = this.read_scalar(flags_op)?.to_machine_isize(&*this.tcx)? as i32;
+        // This argument should be a `c_int` but the syscall API just returns a pointer sized
+        // integer.
+        let flags: i32 = this.try_from_ptr_sized_operand(flags_op)?;
 
-        let at_empty_path = this.eval_libc_i32("AT_EMPTY_PATH")?;
         let at_fdcwd = this.eval_libc_i32("AT_FDCWD")?;
-
         // Now we need to resolve the path of the target file. This was done following the manual
         // entry for `statx`
 
         // If `pathname` is absolute we can ignore `dirfd`.
         let path = if pathname.is_absolute() {
             pathname
         } else {
-            let dirfd = this.read_scalar(dirfd_op)?.to_machine_isize(&*this.tcx)? as i32;
+            // This argument should be a `c_int` but the syscall API just returns a pointer sized
+            // integer.
+            let dirfd: i32 = this.try_from_ptr_sized_operand(dirfd_op)?;
             // If `dirfd` is `AT_FDCWD`, `pathname` is relative to the current directory.
             if dirfd == at_fdcwd {
                 match std::env::current_dir() {
@@ -327,32 +329,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     }
                 }
             } else {
-                if let Some(path) = &this
-                    .machine
-                    .file_handler
-                    .handles
-                    .get(&dirfd)
-                    .map(|h| &h.path)
-                {
-                    // If `dirfd` points to a directory, `pathname` is relative to that directory
-                    if path.is_dir() {
-                        path.join(pathname)
-                    } else {
-                        // If `pathname` is empty and the `AT_EMPTY_PATH` flag is set, we use the path of `dirfd`.
-                        if pathname.as_os_str().is_empty() && (flags & at_empty_path != 0) {
-                            (*path).clone()
-                        } else {
-                            // It is not specified what should happen here.
-                            throw_unsup_format!(
-                                "the file descriptor `{}` and path `{:?}` combination is invalid.",
-                                dirfd,
-                                path
-                            );
-                        }
-                    }
-                } else {
-                    return this.handle_not_found();
-                }
+                // This behavior is specified but cannot be tested from `libstd`. If you found this
+                // error please open an issue reporting it.
+                throw_unsup_format!(
+                    "Using statx with a fildes different from `AT_FDCWD` is not supported"
+                )
             }
         };
 
@@ -385,15 +366,20 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         // The `mode` field specifies the type of the file and the permissions over the file for
         // the owner, its group and other users. Given that we can only provide the file type
         // without using platform specific methods, we only set the bits corresponding to the file
-        // type.
+        // type. This argument should be an `__u16` but the syscall API just returns a pointer sized
+        // integer.
         let mode = if file_type.is_file() {
             this.eval_libc("S_IFREG")?
         } else if file_type.is_dir() {
             this.eval_libc("S_IFDIR")?
         } else {
             this.eval_libc("S_IFLNK")?
-        }
-        .to_u32()? as u16;
+        }.to_u32()?;
+
+        let mode: u16 = mode.try_into().map_err(|e|
+            err_unsup_format!("Failed to convert 32-bit operand to u16: {}",
+            e
+        ))?;
 
         let size = metadata.len();