fix scalar pointer constants

Author: IntegralPilot

src/lower1/operand/const_eval.rs

@@ -2,7 +2,8 @@ use crate::lower1::context::Definitions;
 use rustc_abi::{BackendRepr, FieldIdx, FieldsShape, Size, TagEncoding, VariantIdx, Variants};
 use rustc_hash::FxHashMap as HashMap;
 use rustc_middle::mir::interpret::{
-    AllocId, AllocRange, Allocation, CtfeProvenance, GlobalAlloc, Pointer, Provenance, Scalar,
+    AllocId, AllocInit, AllocRange, Allocation, CtfeProvenance, GlobalAlloc, Pointer, Provenance,
+    Scalar,
 };
 use rustc_middle::ty::consts::ConstExt;
 use rustc_middle::ty::layout::TyAndLayout;
@@ -67,9 +68,7 @@ fn anonymous_memory_identity(
     Some(format!("{}::memory::{hash}", tcx.crate_name(LOCAL_CRATE)))
 }
 
-/// Decode the optimized `ConstValue::Slice` representation. Rust uses that
-/// representation for every reference whose pointee has a slice tail, not
-/// merely for `&str` and `&[T]`.
+/// Decode a pointer-valued scalar, including aggregates with a scalar ABI.
 pub fn read_pointer_constant<'tcx>(
     tcx: TyCtxt<'tcx>,
     pointer: Pointer<CtfeProvenance>,
@@ -89,10 +88,6 @@ pub fn read_pointer_constant<'tcx>(
     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)
@@ -143,7 +138,39 @@ pub fn read_pointer_constant<'tcx>(
                 )
             }
         }
-        _ => read_pointee_constant(tcx, pointer, ty, oomir_data_types, instance),
+        _ => {
+            let layout = tcx
+                .layout_of(TypingEnv::fully_monomorphized().as_query_input(ty))
+                .map_err(|error| format!("Could not determine scalar constant layout: {error:?}"))?;
+            if !matches!(layout.backend_repr, BackendRepr::Scalar(_))
+                || layout.size != tcx.data_layout.pointer_size()
+            {
+                return Err(format!("Unexpected pointer scalar for constant type {ty:?}"));
+            }
+            // This pointer is the aggregate's contents, not its address. Put
+            // the scalar in temporary storage so the normal decoder preserves
+            // enum niches, field types, and function-pointer provenance.
+            let mut allocation =
+                ConstAllocation::new(layout.size, layout.align.abi, AllocInit::Uninit, ());
+            allocation
+                .write_scalar(
+                    &tcx.data_layout,
+                    AllocRange {
+                        start: Size::ZERO,
+                        size: layout.size,
+                    },
+                    Scalar::from_pointer(pointer, &tcx.data_layout),
+                )
+                .map_err(|error| format!("Could not store pointer scalar: {error:?}"))?;
+            read_constant_value_from_memory(
+                tcx,
+                &allocation,
+                Size::ZERO,
+                ty,
+                oomir_data_types,
+                instance,
+            )
+        }
     }
 }
 

tests/binary/fn_pointers/src/constant_options.rs

@@ -0,0 +1,47 @@
+use std::hint::black_box;
+
+trait Property {
+    const FOLD: Option<fn(i32, i32) -> i32>;
+}
+
+struct Sum;
+struct Plain;
+
+impl Property for Sum {
+    const FOLD: Option<fn(i32, i32) -> i32> = Some(add);
+}
+
+impl Property for Plain {
+    const FOLD: Option<fn(i32, i32) -> i32> = None;
+}
+
+fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+
+fn fold<P: Property>(a: i32, b: i32) -> i32 {
+    match black_box(P::FOLD) {
+        Some(f) => f(a, b),
+        None => a,
+    }
+}
+
+pub fn run() {
+    assert_eq!(fold::<Sum>(black_box(19), 23), 42);
+    assert_eq!(fold::<Plain>(black_box(19), 23), 19);
+
+    const CLOSURE: Option<fn(i32) -> i32> = Some(|x| x + 1);
+    assert_eq!(black_box(CLOSURE).unwrap()(41), 42);
+
+    // Scalar ABI aggregates retain their nominal type, even when their only
+    // non-zero-sized field is represented by a pointer during const evaluation.
+    const TUPLE: (Option<fn(i32, i32) -> i32>, ()) = (Some(add), ());
+    assert_eq!(black_box(TUPLE).0.unwrap()(19, 23), 42);
+
+    struct Wrapped(Option<fn(i32, i32) -> i32>);
+    const WRAPPED: Wrapped = Wrapped(Some(add));
+    assert_eq!(black_box(WRAPPED).0.unwrap()(19, 23), 42);
+
+    const REFERENCE: Option<&i32> = Some(&42);
+    assert_eq!(*black_box(REFERENCE).unwrap(), 42);
+}

tests/binary/fn_pointers/src/main.rs

@@ -1,4 +1,5 @@
 mod borrowed_enum;
+mod constant_options;
 
 #[derive(Copy, Clone)]
 enum ComputeStep<T> {
@@ -342,6 +343,7 @@ fn higher_ranked_maybe_uninit_slice() {
 
 fn main() {
     borrowed_enum::run();
+    constant_options::run();
     higher_ranked_maybe_uninit_slice();
     function_pointer_address_roundtrips();