rename ConstValue::ByRef → Indirect

Author: RalfJung

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -222,7 +222,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                 CValue::by_val(val, layout)
             }
         },
-        ConstValue::ByRef { alloc_id, offset } => {
+        ConstValue::Indirect { alloc_id, offset } => {
             let alloc = fx.tcx.global_alloc(alloc_id).unwrap_memory();
             // FIXME: avoid creating multiple allocations for the same AllocId?
             CValue::by_ref(

compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs

@@ -172,7 +172,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                     .expect("simd_shuffle idx not const");
 
                 let idx_bytes = match idx_const {
-                    ConstValue::ByRef { alloc_id, offset } => {
+                    ConstValue::Indirect { alloc_id, offset } => {
                         let alloc = fx.tcx.global_alloc(alloc_id).unwrap_memory();
                         let size = Size::from_bytes(
                             4 * ret_lane_count, /* size_of([u32; ret_lane_count]) */

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -116,7 +116,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                 let b_llval = bx.const_usize((end - start) as u64);
                 OperandValue::Pair(a_llval, b_llval)
             }
-            ConstValue::ByRef { alloc_id, offset } => {
+            ConstValue::Indirect { alloc_id, offset } => {
                 let alloc = bx.tcx().global_alloc(alloc_id).unwrap_memory();
                 // FIXME: should we attempt to avoid building the same AllocId multiple times?
                 return Self::from_const_alloc(bx, layout, alloc, offset);

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -148,7 +148,7 @@ pub(super) fn op_to_const<'tcx>(
     let to_const_value = |mplace: &MPlaceTy<'_>| {
         debug!("to_const_value(mplace: {:?})", mplace);
         match mplace.ptr().into_parts() {
-            (Some(alloc_id), offset) => ConstValue::ByRef { alloc_id, offset },
+            (Some(alloc_id), offset) => ConstValue::Indirect { alloc_id, offset },
             (None, offset) => {
                 assert!(mplace.layout.is_zst());
                 assert_eq!(

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -756,7 +756,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         };
         let layout = from_known_layout(self.tcx, self.param_env, layout, || self.layout_of(ty))?;
         let op = match val_val {
-            ConstValue::ByRef { alloc_id, offset } => {
+            ConstValue::Indirect { alloc_id, offset } => {
                 // We rely on mutability being set correctly in that allocation to prevent writes
                 // where none should happen.
                 let ptr = self.global_base_pointer(Pointer::new(alloc_id, offset))?;

compiler/rustc_middle/src/mir/interpret/value.rs

@@ -38,11 +38,13 @@ pub enum ConstValue<'tcx> {
     /// Only used for ZSTs.
     ZeroSized,
 
-    /// Used only for `&[u8]` and `&str`
+    /// Used only for `&[u8]` and `&str`.
+    ///
+    /// This is worth the optimization since Rust has literals of that type.
     Slice { data: ConstAllocation<'tcx>, start: usize, end: usize },
 
-    /// A value not represented/representable by `Scalar` or `Slice`
-    ByRef {
+    /// A value not represented/representable by the other variants, needs to be stored in-memory.
+    Indirect {
         /// The backing memory of the value. May contain more memory than needed for just the value
         /// if this points into some other larger ConstValue.
         ///
@@ -62,7 +64,7 @@ impl<'tcx> ConstValue<'tcx> {
     #[inline]
     pub fn try_to_scalar(&self) -> Option<Scalar<AllocId>> {
         match *self {
-            ConstValue::ByRef { .. } | ConstValue::Slice { .. } | ConstValue::ZeroSized => None,
+            ConstValue::Indirect { .. } | ConstValue::Slice { .. } | ConstValue::ZeroSized => None,
             ConstValue::Scalar(val) => Some(val),
         }
     }

compiler/rustc_middle/src/mir/mod.rs

@@ -2883,7 +2883,7 @@ fn pretty_print_const_value<'tcx>(
                     _ => {}
                 }
             }
-            (ConstValue::ByRef { alloc_id, offset }, ty::Array(t, n)) if *t == u8_type => {
+            (ConstValue::Indirect { alloc_id, offset }, ty::Array(t, n)) if *t == u8_type => {
                 let n = n.try_to_bits(tcx.data_layout.pointer_size).unwrap();
                 let alloc = tcx.global_alloc(alloc_id).unwrap_memory();
                 // cast is ok because we already checked for pointer size (32 or 64 bit) above

compiler/rustc_middle/src/mir/pretty.rs

@@ -460,7 +460,7 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
                 ConstValue::ZeroSized => "<ZST>".to_string(),
                 ConstValue::Scalar(s) => format!("Scalar({s:?})"),
                 ConstValue::Slice { .. } => "Slice(..)".to_string(),
-                ConstValue::ByRef { .. } => "ByRef(..)".to_string(),
+                ConstValue::Indirect { .. } => "ByRef(..)".to_string(),
             };
 
             let fmt_valtree = |valtree: &ty::ValTree<'tcx>| match valtree {
@@ -708,7 +708,7 @@ pub fn write_allocations<'tcx>(
             }
             ConstValue::ZeroSized => Either::Left(Either::Right(std::iter::empty())),
             ConstValue::Slice { data, .. } => Either::Right(alloc_ids_from_alloc(data)),
-            ConstValue::ByRef { alloc_id, .. } => {
+            ConstValue::Indirect { alloc_id, .. } => {
                 Either::Left(Either::Left(std::iter::once(alloc_id)))
             }
         }

compiler/rustc_mir_transform/src/const_prop.rs

@@ -152,7 +152,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for ConstPropMachine<'mir, 'tcx>
     #[inline(always)]
     fn enforce_alignment(_ecx: &InterpCx<'mir, 'tcx, Self>) -> CheckAlignment {
         // We do not check for alignment to avoid having to carry an `Align`
-        // in `ConstValue::ByRef`.
+        // in `ConstValue::Indirect`.
         CheckAlignment::No
     }
 
@@ -578,7 +578,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                     .ok()?;
 
                 let literal = ConstantKind::Val(
-                    ConstValue::ByRef { alloc_id, offset: Size::ZERO },
+                    ConstValue::Indirect { alloc_id, offset: Size::ZERO },
                     value.layout.ty,
                 );
                 Some(Operand::Constant(Box::new(Constant {

compiler/rustc_mir_transform/src/large_enums.rs

@@ -153,7 +153,7 @@ impl EnumSizeOpt {
                         span,
                         user_ty: None,
                         literal: ConstantKind::Val(
-                            interpret::ConstValue::ByRef { alloc_id, offset: Size::ZERO },
+                            interpret::ConstValue::Indirect { alloc_id, offset: Size::ZERO },
                             tmp_ty,
                         ),
                     };