validate CreateThread args

Author: beepster4096

src/shims/windows/foreign_items.rs

@@ -2,7 +2,6 @@ use std::iter;
 use std::time::{Duration, Instant};
 
 use rustc_middle::mir;
-use rustc_middle::ty::layout::LayoutOf;
 use rustc_span::Symbol;
 use rustc_target::abi::Size;
 use rustc_target::spec::abi::Abi;
@@ -401,19 +400,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
             // Threading
             "CreateThread" => {
-                let [_security, _stacksize, start, arg, _flags, thread] =
+                let [security, stacksize, start, arg, flags, thread] =
                     this.check_shim(abi, Abi::System { unwind: false }, link_name, args)?;
 
-                let thread =
-                    if this.ptr_is_null(this.read_pointer(thread)?)? { None } else { Some(thread) };
-
-                let thread_id = this.start_thread(
-                    thread,
-                    start,
-                    Abi::System { unwind: false },
-                    arg,
-                    this.layout_of(this.tcx.types.u32)?,
-                )?;
+                let thread_id =
+                    this.CreateThread(security, stacksize, start, arg, flags, thread)?;
 
                 this.write_scalar(Handle::Thread(thread_id).to_scalar(this), dest)?;
             }

src/shims/windows/thread.rs

@@ -1,5 +1,8 @@
 use std::time::{Duration, Instant};
 
+use rustc_middle::ty::layout::LayoutOf;
+use rustc_target::spec::abi::Abi;
+
 use crate::thread::Time;
 use crate::*;
 use shims::windows::handle::Handle;
@@ -8,6 +11,40 @@ impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mi
 
 #[allow(non_snake_case)]
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+    fn CreateThread(
+        &mut self,
+        security_op: &OpTy<'tcx, Tag>,
+        stacksize_op: &OpTy<'tcx, Tag>,
+        start_op: &OpTy<'tcx, Tag>,
+        arg_op: &OpTy<'tcx, Tag>,
+        flags_op: &OpTy<'tcx, Tag>,
+        thread_op: &OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, ThreadId> {
+        let this = self.eval_context_mut();
+
+        if !this.ptr_is_null(this.read_pointer(security_op)?)? {
+            throw_unsup_format!("non-null `lpThreadAttributes` in `CreateThread`")
+        }
+
+        // stacksize is ignored, but still needs to be a valid usize
+        let _ = this.read_scalar(stacksize_op)?.to_machine_usize(this)?;
+
+        if this.read_scalar(flags_op)?.to_u32()? != 0 {
+            throw_unsup_format!("non-zero `dwCreationFlags` in `CreateThread`")
+        }
+
+        let thread =
+            if this.ptr_is_null(this.read_pointer(thread_op)?)? { None } else { Some(thread_op) };
+
+        this.start_thread(
+            thread,
+            start_op,
+            Abi::System { unwind: false },
+            arg_op,
+            this.layout_of(this.tcx.types.u32)?,
+        )
+    }
+
     fn WaitForSingleObject(
         &mut self,
         handle: &OpTy<'tcx, Tag>,