decode constant raw pointers canonically

Author: IntegralPilot

src/lower1/operand/const_eval.rs

@@ -1,4 +1,4 @@
-use rustc_abi::{FieldIdx, FieldsShape, Size, TagEncoding, VariantIdx, Variants};
+use rustc_abi::{BackendRepr, FieldIdx, FieldsShape, Size, TagEncoding, VariantIdx, Variants};
 use rustc_middle::mir::interpret::{
     AllocId, AllocRange, Allocation, CtfeProvenance, GlobalAlloc, Pointer, Provenance, Scalar,
 };
@@ -259,7 +259,7 @@ pub fn read_scalar_int_constant<'tcx>(
         });
     }
 
-    if let TyKind::Adt(adt_def, substs) = ty.kind() {
+    if let TyKind::Adt(adt_def, _) = ty.kind() {
         if adt_def.is_enum() {
             // A scalar enum constant is the enum's physical ABI carrier, not
             // necessarily its source-level discriminant. Niche-encoded enums
@@ -281,44 +281,8 @@ pub fn read_scalar_int_constant<'tcx>(
             return scalar_int_to_oomir_constant(tcx, scalar_int, carrier_ty);
         }
 
-        let variant = adt_def
-            .variants()
-            .iter()
-            .next()
-            .ok_or_else(|| format!("Transparent ADT {:?} has no variants", ty))?;
-        let non_zst_fields = variant
-            .fields
-            .iter()
-            .filter(|field_def| {
-                !tcx.layout_of(PseudoCanonicalInput {
-                    typing_env: TypingEnv::post_analysis(tcx, field_def.did),
-                    value: field_def.ty(tcx, substs).skip_norm_wip(),
-                })
-                .map(|layout| layout.is_zst())
-                .unwrap_or(false)
-            })
-            .collect::<Vec<_>>();
-
-        if non_zst_fields.len() != 1 {
-            return Err(format!(
-                "Transparent ADT {:?} has {} non-ZST fields, expected exactly one",
-                ty,
-                non_zst_fields.len()
-            ));
-        }
-
-        let field_def = non_zst_fields[0];
-        let unnormalized_field_ty = field_def.ty(tcx, substs);
-        let field_ty = tcx
-            .try_normalize_erasing_regions(TypingEnv::fully_monomorphized(), unnormalized_field_ty)
-            .map_err(|error| {
-                format!(
-                    "Could not normalize constant field {} of type {:?}: {:?}",
-                    field_def.ident(tcx),
-                    unnormalized_field_ty,
-                    error
-                )
-            })?;
+        let field_ty = scalar_struct_field_ty(tcx, ty)?
+            .ok_or_else(|| format!("Scalar constant ADT {ty:?} did not have one non-ZST field"))?;
         // A scalar ADT is carried using the bits of its one non-ZST field.
         // Keep that physical carrier here and let value-representation
         // adaptation reconstruct the nominal JVM object at the use site.
@@ -332,6 +296,57 @@ pub fn read_scalar_int_constant<'tcx>(
     scalar_int_to_oomir_constant(tcx, scalar_int, ty)
 }
 
+fn scalar_struct_field_ty<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+) -> Result<Option<Ty<'tcx>>, String> {
+    let TyKind::Adt(adt_def, substs) = ty.kind() else {
+        return Ok(None);
+    };
+    if !adt_def.is_struct() {
+        return Ok(None);
+    }
+    let layout = tcx
+        .layout_of(TypingEnv::fully_monomorphized().as_query_input(ty))
+        .map_err(|error| format!("Could not determine constant layout for {ty:?}: {error:?}"))?;
+    if !matches!(layout.backend_repr, BackendRepr::Scalar(_)) {
+        return Ok(None);
+    }
+
+    let variant = adt_def
+        .variants()
+        .iter()
+        .next()
+        .ok_or_else(|| format!("Scalar ADT {ty:?} has no variants"))?;
+    let non_zst_fields = variant
+        .fields
+        .iter()
+        .filter(|field_def| {
+            !tcx.layout_of(PseudoCanonicalInput {
+                typing_env: TypingEnv::post_analysis(tcx, field_def.did),
+                value: field_def.ty(tcx, substs).skip_norm_wip(),
+            })
+            .map(|layout| layout.is_zst())
+            .unwrap_or(false)
+        })
+        .collect::<Vec<_>>();
+    let [field_def] = non_zst_fields.as_slice() else {
+        return Err(format!(
+            "Scalar ADT {ty:?} has {} non-ZST fields, expected exactly one",
+            non_zst_fields.len()
+        ));
+    };
+    let field_ty = field_def.ty(tcx, substs);
+    tcx.try_normalize_erasing_regions(TypingEnv::fully_monomorphized(), field_ty)
+        .map(Some)
+        .map_err(|error| {
+            format!(
+                "Could not normalize constant field {} of type {field_ty:?}: {error:?}",
+                field_def.ident(tcx)
+            )
+        })
+}
+
 pub fn read_zero_sized_constant<'tcx>(
     tcx: TyCtxt<'tcx>,
     ty: Ty<'tcx>,
@@ -513,6 +528,22 @@ pub fn read_pointer_constant<'tcx>(
     oomir_data_types: &mut HashMap<String, oomir::DataType>,
     instance: Instance<'tcx>,
 ) -> Result<oomir::Constant, String> {
+    let ty = EarlyBinder::bind(tcx, ty)
+        .instantiate(tcx, instance.args)
+        .skip_norm_wip();
+    let ty = tcx
+        .try_normalize_erasing_regions(
+            TypingEnv::fully_monomorphized(),
+            rustc_middle::ty::Unnormalized::new_wip(ty),
+        )
+        .unwrap_or(ty);
+    if let TyKind::Pat(inner, _) = ty.kind() {
+        return read_pointer_constant(tcx, pointer, *inner, oomir_data_types, instance);
+    }
+    if let Some(field_ty) = scalar_struct_field_ty(tcx, ty)? {
+        return read_pointer_constant(tcx, pointer, field_ty, oomir_data_types, instance);
+    }
+
     match ty.kind() {
         TyKind::FnPtr(..) => {
             read_function_pointer_constant(tcx, pointer, ty, oomir_data_types, instance)
@@ -1183,9 +1214,20 @@ pub fn read_constant_value_from_memory<'tcx>(
                                 oomir_data_types,
                                 instance,
                             )?;
-                            let pointee_type =
-                                ty_to_oomir_type(*inner_ty, tcx, oomir_data_types, instance);
-                            Ok(oomir::Constant::Array(Box::new(pointee_type), vec![value]))
+                            if matches!(oomir::Type::from_constant(&value), oomir::Type::Pointer(_))
+                            {
+                                // A static reference is already its stable address. Keep that
+                                // Pointer carrier rather than adding a pointer-to-pointer cell.
+                                Ok(value)
+                            } else {
+                                pointer_constant_for_pointee(
+                                    tcx,
+                                    *inner_ty,
+                                    value,
+                                    oomir_data_types,
+                                    instance,
+                                )
+                            }
                         }
                     }
                 }

src/lower1/value_repr.rs

@@ -690,8 +690,50 @@ fn adapt_mutable_reference_carrier<'tcx>(
         return operand_var(dest, target_jvm_ty.clone());
     }
 
+    let target_pointer_ty = match target_rust_ty.kind() {
+        TyKind::Pat(inner, _) => resolved_ty(*inner, tcx, instance),
+        _ => target_rust_ty,
+    };
+    if let (Some(oomir::Type::Pointer(source_inner)), oomir::Type::Pointer(_)) =
+        (source.get_type(), target_jvm_ty)
+        && let TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(pointee_ty, _) =
+            target_pointer_ty.kind()
+    {
+        let pointee_ty = resolved_ty(*pointee_ty, tcx, instance);
+        let source_ty = oomir::Type::Pointer(source_inner);
+        let dest = format!("{temp_prefix}_retyped_pointer");
+        instructions.push(oomir::Instruction::InvokeVirtual {
+            dest: Some(dest.clone()),
+            class_name: oomir::POINTER_CLASS.to_string(),
+            method_name: "retype".to_string(),
+            method_ty: oomir::Signature {
+                params: vec![
+                    ("self".to_string(), source_ty),
+                    ("view_size".to_string(), oomir::Type::U64),
+                    ("view_codec".to_string(), oomir::Type::java_string()),
+                ],
+                ret: Box::new(target_jvm_ty.clone()),
+                is_static: false,
+            },
+            args: vec![
+                oomir::Operand::Constant(oomir::Constant::U64(
+                    u64::try_from(
+                        super::types::layout_size_bytes(tcx, pointee_ty).unwrap_or_else(|error| {
+                            panic!("could not determine pointer view layout: {error}")
+                        }),
+                    )
+                    .expect("pointer view layout exceeds u64"),
+                )),
+                super::types::pointer_view_codec_operand(pointee_ty, tcx, data_types, instance),
+            ],
+            operand: source,
+        });
+        return operand_var(dest, target_jvm_ty.clone());
+    }
+
     if let oomir::Type::Pointer(target_inner) = target_jvm_ty
-        && let TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(pointee_ty, _) = target_rust_ty.kind()
+        && let TyKind::Ref(_, pointee_ty, _) | TyKind::RawPtr(pointee_ty, _) =
+            target_pointer_ty.kind()
     {
         let mut pointee = adapt_operand_to_rust_type(
             source,
@@ -760,8 +802,13 @@ fn adapt_mutable_reference_carrier<'tcx>(
         return operand_var(dest, target_jvm_ty.clone());
     }
 
+    let target_is_scalar_struct = matches!(target_rust_ty.kind(), TyKind::Adt(adt_def, _) if adt_def.is_struct())
+        && tcx
+            .layout_of(TypingEnv::fully_monomorphized().as_query_input(target_rust_ty))
+            .is_ok_and(|layout| matches!(layout.backend_repr, BackendRepr::Scalar(_)));
     if let Some(oomir::Type::Pointer(inner)) = source.get_type()
         && !matches!(target_rust_ty.kind(), TyKind::RawPtr(..) | TyKind::Ref(..))
+        && !target_is_scalar_struct
     {
         return super::place::emit_pointer_read(
             source,

tests/binary/raw_ptrs/src/main.rs

@@ -1718,11 +1718,41 @@ const CONST_PTR: *const i32 = CONST_ARRAY.as_ptr();
 const OFFSET_PTR: *const i32 = unsafe { CONST_PTR.add(2) };
 const PTR_ADDR_IS_NULL: bool = CONST_PTR.is_null();
 
+struct ConstMessage {
+    code: u32,
+}
+
+static CONST_MESSAGE: ConstMessage = ConstMessage { code: 42 };
+
+const CONST_NON_NULL_UNIT: core::ptr::NonNull<()> = unsafe {
+    core::ptr::NonNull::new_unchecked(&CONST_MESSAGE as *const ConstMessage as *mut ())
+};
+
+#[derive(Copy, Clone)]
+struct ConstPointerRepr(core::ptr::NonNull<()>, core::marker::PhantomData<()>);
+
+#[derive(Copy, Clone)]
+struct ConstPointerError {
+    repr: ConstPointerRepr,
+}
+
+const CONST_POINTER_ERROR: ConstPointerError = ConstPointerError {
+    repr: ConstPointerRepr(CONST_NON_NULL_UNIT, core::marker::PhantomData),
+};
+
 fn const_pointer_operations() {
     unsafe {
         assert_eq!(*OFFSET_PTR, 30);
     }
     assert!(!PTR_ADDR_IS_NULL);
+    assert_eq!(
+        CONST_NON_NULL_UNIT.as_ptr(),
+        &CONST_MESSAGE as *const ConstMessage as *mut (),
+    );
+    assert_eq!(
+        CONST_POINTER_ERROR.repr.0.as_ptr(),
+        &CONST_MESSAGE as *const ConstMessage as *mut (),
+    );
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]