avoid marking as immutable what is already immutable

this has been demonstrated to help performance

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -714,11 +714,14 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         _kind: mir::RetagKind,
         val: &ImmTy<'tcx, CtfeProvenance>,
     ) -> InterpResult<'tcx, ImmTy<'tcx, CtfeProvenance>> {
+        // If it's a frozen shared reference that's not already immutable, make it immutable.
+        // (Do nothing on `None` provenance, that cannot store immutability anyway.)
         if let ty::Ref(_, ty, mutbl) = val.layout.ty.kind()
             && *mutbl == Mutability::Not
+            && val.to_scalar_and_meta().0.to_pointer(ecx)?.provenance.is_some_and(|p| !p.immutable())
+            // That next check is expensive, that's why we have all the guards above.
             && ty.is_freeze(*ecx.tcx, ecx.param_env)
         {
-            // This is a frozen shared reference, mark it immutable.
             let place = ecx.ref_to_mplace(val)?;
             let new_place = place.map_provenance(|p| p.map(CtfeProvenance::as_immutable));
             Ok(ImmTy::from_immediate(new_place.to_ref(ecx), val.layout))