Prepare const eval machine for supporting a "no static accesses at all" mode.

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -17,7 +17,7 @@ use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{self, Abi};
 
-use super::{CanAccessMutGlobal, CompileTimeInterpCx, CompileTimeMachine};
+use super::{CompileTimeInterpCx, CompileTimeMachine, GlobalAccessPermissions};
 use crate::const_eval::CheckAlignment;
 use crate::errors::ConstEvalError;
 use crate::errors::{self, DanglingPtrInFinal};
@@ -138,7 +138,7 @@ pub(crate) fn mk_eval_cx_to_read_const_val<'tcx>(
     tcx: TyCtxt<'tcx>,
     root_span: Span,
     param_env: ty::ParamEnv<'tcx>,
-    can_access_mut_global: CanAccessMutGlobal,
+    can_access_mut_global: GlobalAccessPermissions,
 ) -> CompileTimeInterpCx<'tcx> {
     debug!("mk_eval_cx: {:?}", param_env);
     InterpCx::new(
@@ -157,7 +157,8 @@ pub fn mk_eval_cx_for_const_val<'tcx>(
     val: mir::ConstValue<'tcx>,
     ty: Ty<'tcx>,
 ) -> Option<(CompileTimeInterpCx<'tcx>, OpTy<'tcx>)> {
-    let ecx = mk_eval_cx_to_read_const_val(tcx.tcx, tcx.span, param_env, CanAccessMutGlobal::No);
+    let ecx =
+        mk_eval_cx_to_read_const_val(tcx.tcx, tcx.span, param_env, GlobalAccessPermissions::Static);
     let op = ecx.const_val_to_op(val, ty, None).ok()?;
     Some((ecx, op))
 }
@@ -261,7 +262,7 @@ pub(crate) fn turn_into_const_value<'tcx>(
         tcx,
         tcx.def_span(key.value.instance.def_id()),
         key.param_env,
-        CanAccessMutGlobal::from(is_static),
+        GlobalAccessPermissions::from(is_static),
     );
 
     let mplace = ecx.raw_const_to_mplace(constant).expect(
@@ -383,7 +384,7 @@ fn eval_in_interpreter<'tcx, R: InterpretationResult<'tcx>>(
         // they do not have to behave "as if" they were evaluated at runtime.
         // For consts however we want to ensure they behave "as if" they were evaluated at runtime,
         // so we have to reject reading mutable global memory.
-        CompileTimeMachine::new(CanAccessMutGlobal::from(is_static), CheckAlignment::Error),
+        CompileTimeMachine::new(GlobalAccessPermissions::from(is_static), CheckAlignment::Error),
     );
     let res = ecx.load_mir(cid.instance.def, cid.promoted);
     res.and_then(|body| eval_body_using_ecx(&mut ecx, cid, body)).map_err(|error| {

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -58,7 +58,7 @@ pub struct CompileTimeMachine<'tcx> {
     /// Pattern matching on consts with references would be unsound if those references
     /// could point to anything mutable. Therefore, when evaluating consts and when constructing valtrees,
     /// we ensure that only immutable global memory can be accessed.
-    pub(super) can_access_mut_global: CanAccessMutGlobal,
+    pub(super) global_access_permissions: GlobalAccessPermissions,
 
     /// Whether to check alignment during evaluation.
     pub(super) check_alignment: CheckAlignment,
@@ -79,26 +79,28 @@ pub enum CheckAlignment {
 }
 
 #[derive(Copy, Clone, PartialEq)]
-pub(crate) enum CanAccessMutGlobal {
-    No,
-    Yes,
+pub(crate) enum GlobalAccessPermissions {
+    /// Allowed to read from immutable statics
+    Static,
+    /// Allowed to read from mutable statics
+    StaticMut,
 }
 
-impl From<bool> for CanAccessMutGlobal {
+impl From<bool> for GlobalAccessPermissions {
     fn from(value: bool) -> Self {
-        if value { Self::Yes } else { Self::No }
+        if value { Self::StaticMut } else { Self::Static }
     }
 }
 
 impl<'tcx> CompileTimeMachine<'tcx> {
     pub(crate) fn new(
-        can_access_mut_global: CanAccessMutGlobal,
+        global_access_permissions: GlobalAccessPermissions,
         check_alignment: CheckAlignment,
     ) -> Self {
         CompileTimeMachine {
             num_evaluated_steps: 0,
             stack: Vec::new(),
-            can_access_mut_global,
+            global_access_permissions,
             check_alignment,
             static_root_ids: None,
         }
@@ -696,17 +698,18 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
             }
         } else {
             // Read access. These are usually allowed, with some exceptions.
-            if machine.can_access_mut_global == CanAccessMutGlobal::Yes {
+            match machine.global_access_permissions {
                 // Machine configuration allows us read from anything (e.g., `static` initializer).
-                Ok(())
-            } else if alloc.mutability == Mutability::Mut {
-                // Machine configuration does not allow us to read statics (e.g., `const`
-                // initializer).
-                Err(ConstEvalErrKind::ConstAccessesMutGlobal.into())
-            } else {
-                // Immutable global, this read is fine.
-                assert_eq!(alloc.mutability, Mutability::Not);
-                Ok(())
+                GlobalAccessPermissions::StaticMut => Ok(()),
+                GlobalAccessPermissions::Static => match alloc.mutability {
+                    Mutability::Mut => {
+                        // Machine configuration does not allow us to read statics (e.g., `const`
+                        // initializer).
+                        Err(ConstEvalErrKind::ConstAccessesMutGlobal.into())
+                    }
+                    // Immutable global, this read is fine.
+                    Mutability::Not => Ok(()),
+                },
             }
         }
     }

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -11,7 +11,7 @@ use tracing::{debug, instrument, trace};
 use super::eval_queries::{mk_eval_cx_to_read_const_val, op_to_const};
 use super::machine::CompileTimeInterpCx;
 use super::{ValTreeCreationError, ValTreeCreationResult, VALTREE_MAX_NODES};
-use crate::const_eval::CanAccessMutGlobal;
+use crate::const_eval::GlobalAccessPermissions;
 use crate::errors::MaxNumNodesInConstErr;
 use crate::interpret::MPlaceTy;
 use crate::interpret::{
@@ -242,7 +242,7 @@ pub(crate) fn eval_to_valtree<'tcx>(
         param_env,
         // It is absolutely crucial for soundness that
         // we do not read from mutable memory.
-        CanAccessMutGlobal::No,
+        GlobalAccessPermissions::Static,
     );
     let place = ecx.raw_const_to_mplace(const_alloc).unwrap();
     debug!(?place);
@@ -301,8 +301,12 @@ pub fn valtree_to_const_value<'tcx>(
         }
         ty::Pat(ty, _) => valtree_to_const_value(tcx, param_env.and(ty), valtree),
         ty::Ref(_, inner_ty, _) => {
-            let mut ecx =
-                mk_eval_cx_to_read_const_val(tcx, DUMMY_SP, param_env, CanAccessMutGlobal::No);
+            let mut ecx = mk_eval_cx_to_read_const_val(
+                tcx,
+                DUMMY_SP,
+                param_env,
+                GlobalAccessPermissions::Static,
+            );
             let imm = valtree_to_ref(&mut ecx, valtree, inner_ty);
             let imm = ImmTy::from_immediate(imm, tcx.layout_of(param_env_ty).unwrap());
             op_to_const(&ecx, &imm.into(), /* for diagnostics */ false)
@@ -329,8 +333,12 @@ pub fn valtree_to_const_value<'tcx>(
                 bug!("could not find non-ZST field during in {layout:#?}");
             }
 
-            let mut ecx =
-                mk_eval_cx_to_read_const_val(tcx, DUMMY_SP, param_env, CanAccessMutGlobal::No);
+            let mut ecx = mk_eval_cx_to_read_const_val(
+                tcx,
+                DUMMY_SP,
+                param_env,
+                GlobalAccessPermissions::Static,
+            );
 
             // Need to create a place for this valtree.
             let place = create_valtree_place(&mut ecx, layout, valtree);

compiler/rustc_const_eval/src/util/caller_location.rs

@@ -7,7 +7,9 @@ use rustc_middle::ty::{self, Mutability};
 use rustc_span::symbol::Symbol;
 use tracing::trace;
 
-use crate::const_eval::{mk_eval_cx_to_read_const_val, CanAccessMutGlobal, CompileTimeInterpCx};
+use crate::const_eval::{
+    mk_eval_cx_to_read_const_val, CompileTimeInterpCx, GlobalAccessPermissions,
+};
 use crate::interpret::*;
 
 /// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.
@@ -62,7 +64,7 @@ pub(crate) fn const_caller_location_provider(
         tcx.tcx,
         tcx.span,
         ty::ParamEnv::reveal_all(),
-        CanAccessMutGlobal::No,
+        GlobalAccessPermissions::Static,
     );
 
     let loc_place = alloc_caller_location(&mut ecx, file, line, col);

compiler/rustc_const_eval/src/util/check_validity_requirement.rs

@@ -3,7 +3,7 @@ use rustc_middle::ty::layout::{LayoutCx, LayoutError, LayoutOf, TyAndLayout, Val
 use rustc_middle::ty::{ParamEnv, ParamEnvAnd, Ty, TyCtxt};
 use rustc_target::abi::{Abi, FieldsShape, Scalar, Variants};
 
-use crate::const_eval::{CanAccessMutGlobal, CheckAlignment, CompileTimeMachine};
+use crate::const_eval::{CheckAlignment, CompileTimeMachine, GlobalAccessPermissions};
 use crate::interpret::{InterpCx, MemoryKind, OpTy};
 
 /// Determines if this type permits "raw" initialization by just transmuting some memory into an
@@ -45,7 +45,7 @@ fn might_permit_raw_init_strict<'tcx>(
     tcx: TyCtxt<'tcx>,
     kind: ValidityRequirement,
 ) -> Result<bool, &'tcx LayoutError<'tcx>> {
-    let machine = CompileTimeMachine::new(CanAccessMutGlobal::No, CheckAlignment::Error);
+    let machine = CompileTimeMachine::new(GlobalAccessPermissions::Static, CheckAlignment::Error);
 
     let mut cx = InterpCx::new(tcx, rustc_span::DUMMY_SP, ParamEnv::reveal_all(), machine);