Handle dyn* coercions for values that are represented with OperandValue::Ref

Author: compiler-errors

compiler/rustc_codegen_ssa/src/base.rs

@@ -276,6 +276,10 @@ pub fn cast_to_dyn_star<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     // FIXME(dyn-star): We can remove this when all supported LLVMs use opaque ptrs only.
     let unit_ptr = bx.cx().type_ptr_to(bx.cx().type_struct(&[], false));
     let src = match bx.cx().type_kind(bx.cx().backend_type(src_ty_and_layout)) {
+        // if `is_backend_immediate` is not true, then the value is
+        // represented by an `OperandValue::Ref`, and it's already
+        // been read into a usize.
+        _ if !bx.cx().is_backend_immediate(src_ty_and_layout) => src,
         TypeKind::Pointer => bx.pointercast(src, unit_ptr),
         TypeKind::Integer => bx.inttoptr(src, unit_ptr),
         // FIXME(dyn-star): We probably have to do a bitcast first, then inttoptr.

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -270,9 +270,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     }
                     mir::CastKind::DynStar => {
                         let (lldata, llextra) = match operand.val {
-                            OperandValue::Ref(_, _, _) => todo!(),
+                            OperandValue::Ref(ptr, None, align) => {
+                                // Read the value as a `usize` -- this should be possible,
+                                // since the value is guaranteed to be a properly aligned
+                                // and sized.
+                                let isize_ptr_ty = bx.cx().type_ptr_to(bx.cx().type_isize());
+                                let ptr = bx.pointercast(ptr, isize_ptr_ty);
+                                let v = bx.load(bx.cx().type_isize(), ptr, align);
+                                (v, None)
+                            }
                             OperandValue::Immediate(v) => (v, None),
                             OperandValue::Pair(v, l) => (v, Some(l)),
+                            OperandValue::Ref(a, b, _) =>
+                                bug!("unexpected operand cast to dyn*: lldata={a:?} llextra={b:?}"),
                         };
                         let (lldata, llextra) =
                             base::cast_to_dyn_star(bx, lldata, operand.layout, cast.ty, llextra);

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -123,12 +123,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             DynStar => {
                 if let ty::Dynamic(data, _, ty::DynStar) = cast_ty.kind() {
                     // Initial cast from sized to dyn trait
+                    // Copy the data into the first field of the destination.
+                    // (Can be a non-immediate type, so we have to do a proper copy.)
+                    let data_dest = self.place_field(dest, 0)?;
+                    self.copy_op(src, &data_dest, true)?;
+
+                    // Copy the vtable into the second field of the destination.
                     let vtable = self.get_vtable_ptr(src.layout.ty, data.principal())?;
-                    let vtable = Scalar::from_maybe_pointer(vtable, self);
-                    let data = self.read_immediate(src)?.to_scalar();
-                    let _assert_pointer_like = data.to_pointer(self)?;
-                    let val = Immediate::ScalarPair(data, vtable);
-                    self.write_immediate(val, dest)?;
+                    let vtable_dest = self.place_field(dest, 1)?;
+                    self.write_pointer(vtable, &vtable_dest)?;
                 } else {
                     bug!()
                 }

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -404,7 +404,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Abi::Scalar(abi::Scalar::Initialized { .. })
                 | Abi::ScalarPair(abi::Scalar::Initialized { .. }, abi::Scalar::Initialized { .. })
         ) {
-            span_bug!(self.cur_span(), "primitive read not possible for type: {:?}", op.layout.ty);
+            span_bug!(self.cur_span(), "primitive read not possible for: {:?}", op.layout);
         }
         let imm = self.read_immediate_raw(op)?.right().unwrap();
         if matches!(*imm, Immediate::Uninit) {

compiler/rustc_middle/src/ty/layout.rs

@@ -774,12 +774,7 @@ where
                         TyMaybeWithLayout::Ty(tcx.mk_mut_ptr(tcx.types.unit))
                     } else if i == 1 {
                         // FIXME(dyn-star) same FIXME as above applies here too
-                        TyMaybeWithLayout::Ty(
-                            tcx.mk_imm_ref(
-                                tcx.lifetimes.re_static,
-                                tcx.mk_array(tcx.types.usize, 3),
-                            ),
-                        )
+                        TyMaybeWithLayout::Ty(tcx.mk_imm_ptr(tcx.mk_array(tcx.types.usize, 3)))
                     } else {
                         bug!("no field {i} on dyn*")
                     }

src/tools/miri/tests/pass/dyn-star-aggregate.rs

@@ -0,0 +1,13 @@
+#![feature(dyn_star)]
+#![allow(incomplete_features)]
+
+use std::fmt::Debug;
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct Foo(usize);
+
+fn main() {
+    let x = Foo(1) as dyn* Debug;
+    assert_eq!(format!("{x:?}"), "Foo(1)");
+}