diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index 70c152b40c0d2..71445664823eb 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -452,7 +452,6 @@ impl<'a> HashStable> for mir::interpret::Allocation { } self.undef_mask.hash_stable(hcx, hasher); self.align.hash_stable(hcx, hasher); - self.runtime_mutability.hash_stable(hcx, hasher); } } diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs index c9eed0e4a2885..b3a93ca522dc5 100644 --- a/src/librustc/mir/interpret/mod.rs +++ b/src/librustc/mir/interpret/mod.rs @@ -20,7 +20,6 @@ use ty::{self, TyCtxt}; use ty::layout::{self, Align, HasDataLayout}; use middle::region; use std::iter; -use syntax::ast::Mutability; use rustc_serialize::{Encoder, Decoder, Decodable, Encodable}; #[derive(Clone, Debug, PartialEq)] @@ -247,10 +246,6 @@ pub struct Allocation { pub undef_mask: UndefMask, /// The alignment of the allocation to detect unaligned reads. pub align: Align, - /// Whether the allocation (of a static) should be put into mutable memory when translating - /// - /// Only happens for `static mut` or `static` with interior mutability - pub runtime_mutability: Mutability, } impl Allocation { @@ -262,7 +257,6 @@ impl Allocation { relocations: BTreeMap::new(), undef_mask, align: Align::from_bytes(1, 1).unwrap(), - runtime_mutability: Mutability::Immutable, } } } diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs index 6fa68eb6ff1f0..d605e6354917f 100644 --- a/src/librustc_mir/interpret/const_eval.rs +++ b/src/librustc_mir/interpret/const_eval.rs @@ -115,14 +115,7 @@ fn eval_body_and_ecx<'a, 'mir, 'tcx>( layout.align, None, )?; - let internally_mutable = !layout.ty.is_freeze(tcx, param_env, mir.span); - let mutability = tcx.is_static(cid.instance.def_id()); - let mutability = if mutability == Some(hir::Mutability::MutMutable) || internally_mutable { - Mutability::Mutable - } else { - Mutability::Immutable - }; - let cleanup = StackPopCleanup::MarkStatic(mutability); + let cleanup = StackPopCleanup::MarkStatic; let name = ty::tls::with(|tcx| tcx.item_path_str(cid.instance.def_id())); let prom = cid.promoted.map_or(String::new(), |p| format!("::promoted[{:?}]", p)); trace!("const_eval: pushing stack frame for global: {}{}", name, prom); @@ -315,7 +308,6 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator { fn mark_static_initialized<'a>( _mem: &mut Memory<'a, 'mir, 'tcx, Self>, _id: AllocId, - _mutability: Mutability, ) -> EvalResult<'tcx, bool> { Ok(false) } diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index a5ddd50ae10c5..b42999d24fdc9 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -12,7 +12,6 @@ use rustc::ty::maps::TyCtxtAt; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; use rustc::middle::const_val::FrameInfo; use syntax::codemap::{self, Span}; -use syntax::ast::Mutability; use rustc::mir::interpret::{ GlobalId, Value, Pointer, PrimVal, PrimValKind, EvalError, EvalResult, EvalErrorKind, MemoryPointer, @@ -96,7 +95,7 @@ pub enum StackPopCleanup { /// isn't modifyable afterwards in case of constants. /// In case of `static mut`, mark the memory to ensure it's never marked as immutable through /// references or deallocated - MarkStatic(Mutability), + MarkStatic, /// A regular stackframe added due to a function call will need to get forwarded to the next /// block Goto(mir::BasicBlock), @@ -440,12 +439,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M self.memory.cur_frame = self.cur_frame(); } match frame.return_to_block { - StackPopCleanup::MarkStatic(mutable) => { + StackPopCleanup::MarkStatic => { if let Place::Ptr { ptr, .. } = frame.return_place { // FIXME: to_ptr()? might be too extreme here, static zsts might reach this under certain conditions self.memory.mark_static_initialized( ptr.to_ptr()?.alloc_id, - mutable, )? } else { bug!("StackPopCleanup::MarkStatic on: {:?}", frame.return_place); diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs index 5af0a053e9239..44825897b0fe0 100644 --- a/src/librustc_mir/interpret/machine.rs +++ b/src/librustc_mir/interpret/machine.rs @@ -63,7 +63,6 @@ pub trait Machine<'mir, 'tcx>: Sized { fn mark_static_initialized<'a>( _mem: &mut Memory<'a, 'mir, 'tcx, Self>, _id: AllocId, - _mutability: Mutability, ) -> EvalResult<'tcx, bool>; /// Called when requiring a pointer to a static. Non const eval can diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs index dcf97f61545db..2a3f51c6f1a05 100644 --- a/src/librustc_mir/interpret/memory.rs +++ b/src/librustc_mir/interpret/memory.rs @@ -5,7 +5,6 @@ use std::{ptr, io}; use rustc::ty::Instance; use rustc::ty::maps::TyCtxtAt; use rustc::ty::layout::{self, Align, TargetDataLayout}; -use syntax::ast::Mutability; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc::mir::interpret::{MemoryPointer, AllocId, Allocation, AccessKind, UndefMask, Value, Pointer, @@ -91,7 +90,6 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> { relocations: BTreeMap::new(), undef_mask: UndefMask::new(size), align, - runtime_mutability: Mutability::Immutable, }; let id = self.tcx.interpret_interner.reserve(); M::add_lock(self, id); @@ -499,13 +497,12 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> { fn mark_inner_allocation_initialized( &mut self, alloc: AllocId, - mutability: Mutability, ) -> EvalResult<'tcx> { match self.alloc_kind.get(&alloc) { // do not go into statics None => Ok(()), // just locals and machine allocs - Some(_) => self.mark_static_initialized(alloc, mutability), + Some(_) => self.mark_static_initialized(alloc), } } @@ -513,15 +510,13 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> { pub fn mark_static_initialized( &mut self, alloc_id: AllocId, - mutability: Mutability, ) -> EvalResult<'tcx> { trace!( - "mark_static_initialized {:?}, mutability: {:?}", + "mark_static_initialized {:?}", alloc_id, - mutability ); // The machine handled it - if M::mark_static_initialized(self, alloc_id, mutability)? { + if M::mark_static_initialized(self, alloc_id)? { return Ok(()) } let alloc = self.alloc_map.remove(&alloc_id); @@ -531,14 +526,12 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> { Some(MemoryKind::Stack) => {}, } let uninit = self.uninitialized_statics.remove(&alloc_id); - if let Some(mut alloc) = alloc.or(uninit) { - // ensure llvm knows not to put this into immutable memroy - alloc.runtime_mutability = mutability; + if let Some(alloc) = alloc.or(uninit) { let alloc = self.tcx.intern_const_alloc(alloc); self.tcx.interpret_interner.intern_at_reserved(alloc_id, alloc); // recurse into inner allocations for &alloc in alloc.relocations.values() { - self.mark_inner_allocation_initialized(alloc, mutability)?; + self.mark_inner_allocation_initialized(alloc)?; } } else { bug!("no allocation found for {:?}", alloc_id); diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs index ded27108e716a..3a5dcb3ab01b2 100644 --- a/src/librustc_mir/interpret/traits.rs +++ b/src/librustc_mir/interpret/traits.rs @@ -1,6 +1,5 @@ use rustc::ty::{self, Ty}; use rustc::ty::layout::{Size, Align, LayoutOf}; -use syntax::ast::Mutability; use rustc::mir::interpret::{PrimVal, Value, MemoryPointer, EvalResult}; use super::{EvalContext, Machine}; @@ -53,7 +52,6 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> { self.memory.mark_static_initialized( vtable.alloc_id, - Mutability::Immutable, )?; Ok(vtable) diff --git a/src/librustc_trans/mir/constant.rs b/src/librustc_trans/mir/constant.rs index 6e07b8e73ef22..bd747eade6031 100644 --- a/src/librustc_trans/mir/constant.rs +++ b/src/librustc_trans/mir/constant.rs @@ -23,7 +23,6 @@ use common::{C_bytes, C_struct, C_uint_big, C_undef, C_usize}; use consts; use type_of::LayoutLlvmExt; use type_::Type; -use syntax::ast::Mutability; use super::super::callee; use super::FunctionCx; @@ -57,11 +56,7 @@ pub fn primval_to_llvm(cx: &CodegenCx, } else if let Some(alloc) = cx.tcx.interpret_interner .get_alloc(ptr.alloc_id) { let init = global_initializer(cx, alloc); - if alloc.runtime_mutability == Mutability::Mutable { - consts::addr_of_mut(cx, init, alloc.align, "byte_str") - } else { - consts::addr_of(cx, init, alloc.align, "byte_str") - } + consts::addr_of(cx, init, alloc.align, "byte_str") } else { bug!("missing allocation {:?}", ptr.alloc_id); };