diff options
| author | Lukas Markeffsky <@> | 2025-01-09 17:34:58 +0000 |
|---|---|---|
| committer | Lukas Markeffsky <@> | 2025-01-31 17:43:28 +0100 |
| commit | a90cb05da642607545560fb64dd057d3fedf2e97 (patch) | |
| tree | d657c8f9bb4fc8060c911b4e219daa8cbf550e66 /src | |
| parent | 7f36543a48e52912ac6664a70c0a5b9d86509eaf (diff) | |
interpret: adjust vtable validity check for higher-ranked types
Diffstat (limited to 'src')
3 files changed, 75 insertions, 0 deletions
diff --git a/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.rs b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.rs new file mode 100644 index 00000000000..7de4aef422a --- /dev/null +++ b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.rs @@ -0,0 +1,30 @@ +// Test that transmuting from `&dyn Trait<fn(&'static ())>` to `&dyn Trait<for<'a> fn(&'a ())>` is UB. +// +// The vtable of `() as Trait<fn(&'static ())>` and `() as Trait<for<'a> fn(&'a ())>` can have +// different entries and, because in the former the entry for `foo` is vacant, this test will +// segfault at runtime. + +trait Trait<U> { + fn foo(&self) + where + U: HigherRanked, + { + } +} +impl<T, U> Trait<U> for T {} + +trait HigherRanked {} +impl HigherRanked for for<'a> fn(&'a ()) {} + +// 2nd candidate is required so that selecting `(): Trait<fn(&'static ())>` will +// evaluate the candidates and fail the leak check instead of returning the +// only applicable candidate. +trait Unsatisfied {} +impl<T: Unsatisfied> HigherRanked for T {} + +fn main() { + let x: &dyn Trait<fn(&'static ())> = &(); + let y: &dyn Trait<for<'a> fn(&'a ())> = unsafe { std::mem::transmute(x) }; + //~^ ERROR: wrong trait in wide pointer vtable + y.foo(); +} diff --git a/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr new file mode 100644 index 00000000000..cfdf279a605 --- /dev/null +++ b/src/tools/miri/tests/fail/validity/dyn-transmute-inner-binder.stderr @@ -0,0 +1,15 @@ +error: Undefined Behavior: constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<for<'a> fn(&'a ())>`, but encountered `Trait<fn(&())>` + --> tests/fail/validity/dyn-transmute-inner-binder.rs:LL:CC + | +LL | let y: &dyn Trait<for<'a> fn(&'a ())> = unsafe { std::mem::transmute(x) }; + | ^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: wrong trait in wide pointer vtable: expected `Trait<for<'a> fn(&'a ())>`, but encountered `Trait<fn(&())>` + | + = 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 `main` at tests/fail/validity/dyn-transmute-inner-binder.rs:LL:CC + +note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace + +error: aborting due to 1 previous error + diff --git a/src/tools/miri/tests/pass/dyn-upcast.rs b/src/tools/miri/tests/pass/dyn-upcast.rs index f100c4d6a86..394e80aa257 100644 --- a/src/tools/miri/tests/pass/dyn-upcast.rs +++ b/src/tools/miri/tests/pass/dyn-upcast.rs @@ -12,6 +12,7 @@ fn main() { drop_principal(); modulo_binder(); modulo_assoc(); + bidirectional_subtyping(); } fn vtable_nop_cast() { @@ -534,3 +535,32 @@ fn modulo_assoc() { (&() as &dyn Trait as &dyn Middle<()>).say_hello(&0); } + +fn bidirectional_subtyping() { + // Test that transmuting between subtypes of dyn traits is fine, even in the + // "wrong direction", i.e. going from a lower-ranked to a higher-ranked dyn trait. + // Note that compared to the `dyn-transmute-inner-binder` test, the `for` is on the + // *outside* here! + + trait Trait<U: ?Sized> {} + impl<T, U: ?Sized> Trait<U> for T {} + + struct Wrapper<T: ?Sized>(T); + + let x: &dyn Trait<fn(&'static ())> = &(); + let _y: &dyn for<'a> Trait<fn(&'a ())> = unsafe { std::mem::transmute(x) }; + + let x: &dyn for<'a> Trait<fn(&'a ())> = &(); + let _y: &dyn Trait<fn(&'static ())> = unsafe { std::mem::transmute(x) }; + + let x: &dyn Trait<dyn Trait<fn(&'static ())>> = &(); + let _y: &dyn for<'a> Trait<dyn Trait<fn(&'a ())>> = unsafe { std::mem::transmute(x) }; + + let x: &dyn for<'a> Trait<dyn Trait<fn(&'a ())>> = &(); + let _y: &dyn Trait<dyn Trait<fn(&'static ())>> = unsafe { std::mem::transmute(x) }; + + // This lowers to a ptr-to-ptr cast (which behaves like a transmute) + // and not an unsizing coercion: + let x: *const dyn for<'a> Trait<&'a ()> = &(); + let _y: *const Wrapper<dyn Trait<&'static ()>> = x as _; +} |
