Auto merge of #2314 - RalfJung:unsized, r=RalfJung

adjust for removed unsized_locals

The Miri side of rust-lang/rust#98831

rust-version

@@ -1 +1 @@
-7665c3543079ebc3710b676d0fd6951bedfd4b29
+8824d131619e58a38bde8bcf56401629b91a204a

src/machine.rs

@@ -169,7 +169,7 @@ impl Provenance for Tag {
  write!(f, "{:?}", sb)?;
  }
  Tag::Wildcard => {
- write!(f, "[Wildcard]")?;
+ write!(f, "[wildcard]")?;
  }
  }
 

src/operator.rs

@@ -35,11 +35,13 @@ impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
  Immediate::Scalar(l) => (l.check_init()?.to_bits(size)?, 0),
  Immediate::ScalarPair(l1, l2) =>
  (l1.check_init()?.to_bits(size)?, l2.check_init()?.to_bits(size)?),
+ Immediate::Uninit => throw_ub!(InvalidUninitBytes(None)),
  };
  let right = match **right {
  Immediate::Scalar(r) => (r.check_init()?.to_bits(size)?, 0),
  Immediate::ScalarPair(r1, r2) =>
  (r1.check_init()?.to_bits(size)?, r2.check_init()?.to_bits(size)?),
+ Immediate::Uninit => throw_ub!(InvalidUninitBytes(None)),
  };
  let res = match bin_op {
  Eq => left == right,

src/shims/intrinsics.rs

@@ -68,12 +68,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
  "volatile_load" => {
  let [place] = check_arg_count(args)?;
  let place = this.deref_operand(place)?;
- this.copy_op(&place.into(), dest)?;
+ this.copy_op(&place.into(), dest, /*allow_transmute*/ false)?;
  }
  "volatile_store" => {
  let [place, dest] = check_arg_count(args)?;
  let place = this.deref_operand(place)?;
- this.copy_op(dest, &place.into())?;
+ this.copy_op(dest, &place.into(), /*allow_transmute*/ false)?;
  }
 
  "write_bytes" | "volatile_set_memory" => {

tests/fail/data_race/stack_pop_race.rs

@@ -0,0 +1,25 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+// compile-flags: -Zmiri-preemption-rate=0
+use std::thread;
+
+#[derive(Copy, Clone)]
+struct MakeSend(*const i32);
+unsafe impl Send for MakeSend {}
+
+fn main() {
+ race(0);
+}
+
+// Using an argument for the ptr to point to, since those do not get StorageDead.
+fn race(local: i32) {
+ let ptr = MakeSend(&local as *const i32);
+ thread::spawn(move || {
+ let ptr = ptr;
+ let _val = unsafe { *ptr.0 };
+ });
+ // Make the other thread go first so that it does not UAF.
+ thread::yield_now();
+ // Deallocating the local (when `main` returns)
+ // races with the read in the other thread.
+ // Make sure the error points at this function's end, not just the call site.
+} //~ERROR Data race detected between Deallocate on thread `main` and Read on thread `<unnamed>`

tests/fail/data_race/stack_pop_race.stderr

@@ -0,0 +1,20 @@
+error: Undefined Behavior: Data race detected between Deallocate on thread `main` and Read on thread `<unnamed>` at ALLOC
+ --> $DIR/stack_pop_race.rs:LL:CC
+ |
+LL | }
+ | ^ Data race detected between Deallocate on thread `main` and Read on thread `<unnamed>` at ALLOC
+ |
+ = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+ = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+ = note: backtrace:
+ = note: inside `race` at $DIR/stack_pop_race.rs:LL:CC
+note: inside `main` at $DIR/stack_pop_race.rs:LL:CC
+ --> $DIR/stack_pop_race.rs:LL:CC
+ |
+LL | fn main() { race(0); }
+ | ^^^^^^^
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to previous error
+

tests/fail/unsized-local.rs

@@ -0,0 +1,23 @@
+#![feature(unsized_locals)]
+#![allow(incomplete_features)]
+
+fn main() {
+ pub trait Foo {
+ fn foo(self) -> String;
+ }
+
+ struct A;
+
+ impl Foo for A {
+ fn foo(self) -> String {
+ format!("hello")
+ }
+ }
+
+ let x = *(Box::new(A) as Box<dyn Foo>); //~ERROR unsized locals are not supported
+ assert_eq!(x.foo(), format!("hello"));
+
+ // I'm not sure whether we want this to work
+ let x = Box::new(A) as Box<dyn Foo>;
+ assert_eq!(x.foo(), format!("hello"));
+}

tests/fail/unsized-local.stderr

@@ -0,0 +1,14 @@
+error: unsupported operation: unsized locals are not supported
+ --> $DIR/unsized-local.rs:LL:CC
+ |
+LL | let x = *(Box::new(A) as Box<dyn Foo>);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsized locals are not supported
+ |
+ = help: this is likely not a bug in the program; it indicates that the program performed an operation that the interpreter does not support
+ = note: backtrace:
+ = note: inside `main` at $DIR/unsized-local.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to previous error
+

tests/pass/dyn-traits.rs

@@ -1,6 +1,3 @@
-#![feature(unsized_locals, unsized_fn_params)]
-#![allow(incomplete_features)]
-
 fn ref_box_dyn() {
  struct Struct(i32);
 
@@ -75,6 +72,9 @@ fn box_box_trait() {
  assert!(unsafe { DROPPED });
 }
 
+// Disabled for now: unsized locals are not supported,
+// their current MIR encoding is just not great.
+/*
 fn unsized_dyn() {
  pub trait Foo {
  fn foo(self) -> String;
@@ -95,7 +95,6 @@ fn unsized_dyn() {
  let x = Box::new(A) as Box<dyn Foo>;
  assert_eq!(x.foo(), format!("hello"));
 }
-
 fn unsized_dyn_autoderef() {
  pub trait Foo {
  fn foo(self) -> String;
@@ -140,12 +139,9 @@ fn unsized_dyn_autoderef() {
  let x = Box::new(|| "hello".to_owned()) as Box<dyn FnMut() -> String>;
  assert_eq!(&x.foo() as &str, "hello");
 }
+*/
 
 fn main() {
  ref_box_dyn();
  box_box_trait();
-
- // "exotic" receivers
- unsized_dyn();
- unsized_dyn_autoderef();
 }

tests/pass/transmute_fat.rs

@@ -3,6 +3,7 @@
 
 fn main() {
  // If we are careful, we can exploit data layout...
+ // This is a tricky case since we are transmuting a ScalarPair type to a non-ScalarPair type.
  let raw = unsafe { std::mem::transmute::<&[u8], [*const u8; 2]>(&[42]) };
  let ptr: *const u8 = unsafe { std::mem::transmute_copy(&raw) };
  assert_eq!(unsafe { *ptr }, 42);

tests/pass/unsized.rs

@@ -0,0 +1,36 @@
+#![feature(unsized_tuple_coercion)]
+#![feature(unsized_fn_params)]
+
+use std::mem;
+
+fn unsized_tuple() {
+ let x: &(i32, i32, [i32]) = &(0, 1, [2, 3]);
+ let y: &(i32, i32, [i32]) = &(0, 1, [2, 3, 4]);
+ let mut a = [y, x];
+ a.sort();
+ assert_eq!(a, [x, y]);
+
+ assert_eq!(&format!("{:?}", a), "[(0, 1, [2, 3]), (0, 1, [2, 3, 4])]");
+ assert_eq!(mem::size_of_val(x), 16);
+}
+
+fn unsized_params() {
+ pub fn f0(_f: dyn FnOnce()) {}
+ pub fn f1(_s: str) {}
+ pub fn f2(_x: i32, _y: [i32]) {}
+ pub fn f3(_p: dyn Send) {}
+
+ let c: Box<dyn FnOnce()> = Box::new(|| {});
+ f0(*c);
+ let foo = "foo".to_string().into_boxed_str();
+ f1(*foo);
+ let sl: Box<[i32]> = [0, 1, 2].to_vec().into_boxed_slice();
+ f2(5, *sl);
+ let p: Box<dyn Send> = Box::new((1, 2));
+ f3(*p);
+}
+
+fn main() {
+ unsized_tuple();
+ unsized_params();
+}