Rustup

diff --git a/src/fn_call.rs b/src/fn_call.rs
index 36cc29a2b5b5b7690c3dc92e3e8f98416dffc300..1c3998a4f022fa3585cf091beb59be85c0929bf2 100644 (file)
--- a/src/fn_call.rs
+++ b/src/fn_call.rs
@@ -199,7 +199,7 @@ fn call_c_abi(
                     self.write_null(dest, dest_ty)?;
                 } else {
                     let align = self.tcx.data_layout.pointer_align;
-                    let ptr = self.memory.allocate(Size::from_bytes(size), align, Some(MemoryKind::C.into()))?;
+                    let ptr = self.memory.allocate(Size::from_bytes(size), align, MemoryKind::C.into())?;
                     self.write_scalar(dest, Scalar::Ptr(ptr), dest_ty)?;
                 }
             }
@@ -395,7 +395,7 @@ fn call_c_abi(
                     let value_copy = self.memory.allocate(
                         Size::from_bytes((value.len() + 1) as u64),
                         Align::from_bytes(1, 1).unwrap(),
-                        Some(MemoryKind::Env.into()),
+                        MemoryKind::Env.into(),
                     )?;
                     self.memory.write_bytes(value_copy.into(), &value)?;
                     let trailing_zero_ptr = value_copy.offset(Size::from_bytes(value.len() as u64), &self)?.into();
@@ -656,7 +656,7 @@ fn call_missing_fn(
                 }
                 let ptr = self.memory.allocate(Size::from_bytes(size),
                                                Align::from_bytes(align, align).unwrap(),
-                                               Some(MemoryKind::Rust.into()))?;
+                                               MemoryKind::Rust.into())?;
                 self.write_scalar(dest, Scalar::Ptr(ptr), dest_ty)?;
             }
             "alloc::alloc::::__rust_alloc_zeroed" => {
@@ -670,7 +670,7 @@ fn call_missing_fn(
                 }
                 let ptr = self.memory.allocate(Size::from_bytes(size),
                                                Align::from_bytes(align, align).unwrap(),
-                                               Some(MemoryKind::Rust.into()))?;
+                                               MemoryKind::Rust.into())?;
                 self.memory.write_repeat(ptr.into(), 0, Size::from_bytes(size))?;
                 self.write_scalar(dest, Scalar::Ptr(ptr), dest_ty)?;
             }

diff --git a/src/lib.rs b/src/lib.rs
index 896c8c5428fbd25a66127d1b890501ae1e5ec684..d6b0bd045099e1967746a2bbdeebacaf2a02c74b 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -171,7 +171,7 @@ pub fn create_ecx<'a, 'mir: 'a, 'tcx: 'mir>(
         // Return value
         let size = ecx.tcx.data_layout.pointer_size;
         let align = ecx.tcx.data_layout.pointer_align;
-        let ret_ptr = ecx.memory_mut().allocate(size, align, Some(MemoryKind::Stack))?;
+        let ret_ptr = ecx.memory_mut().allocate(size, align, MemoryKind::Stack)?;
         cleanup_ptr = Some(ret_ptr);
 
         // Push our stack frame
@@ -210,7 +210,7 @@ pub fn create_ecx<'a, 'mir: 'a, 'tcx: 'mir>(
         let foo = ecx.memory.allocate_bytes(b"foo\0");
         let ptr_size = ecx.memory.pointer_size();
         let ptr_align = ecx.tcx.data_layout.pointer_align;
-        let foo_ptr = ecx.memory.allocate(ptr_size, ptr_align, None)?;
+        let foo_ptr = ecx.memory.allocate(ptr_size, ptr_align, MemoryKind::Stack)?;
         ecx.memory.write_scalar(foo_ptr.into(), ptr_align, Scalar::Ptr(foo), ptr_size, false)?;
         ecx.memory.mark_static_initialized(foo_ptr.alloc_id, Mutability::Immutable)?;
         ecx.write_ptr(dest, foo_ptr.into(), ty)?;
@@ -269,10 +269,10 @@ pub fn eval_main<'a, 'tcx: 'a>(
                     block.terminator().source_info.span
                 };
 
-                let mut err = mir::interpret::struct_error(ecx.tcx.tcx.at(span), "constant evaluation error");
+                let mut err = struct_error(ecx.tcx.tcx.at(span), "constant evaluation error");
                 let (frames, span) = ecx.generate_stacktrace(None);
                 err.span_label(span, e.to_string());
-                for mir::interpret::FrameInfo { span, location, .. } in frames {
+                for FrameInfo { span, location, .. } in frames {
                     err.span_note(span, &format!("inside call to `{}`", location));
                 }
                 err.emit();
@@ -404,7 +404,7 @@ fn init_static<'a>(
         let ptr = ecx.memory.allocate(
             layout.size,
             layout.align,
-            None,
+            MemoryKind::Stack,
         )?;
 
         // Step 4: Cache allocation id for recursive statics

diff --git a/src/validation.rs b/src/validation.rs
index 90ac0a803f9b3a8b02084576953d319191e6c418..851f5df9792e42f014cee6d8245effb7703a2f19 100644 (file)
--- a/src/validation.rs
+++ b/src/validation.rs
@@ -8,6 +8,7 @@
 use rustc::traits::{self, TraitEngine};
 use rustc::infer::InferCtxt;
 use rustc::middle::region;
+use rustc::mir::interpret::{ConstValue};
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_mir::interpret::HasMemory;
 
@@ -718,7 +719,7 @@ fn validate(
                 }
                 TyArray(elem_ty, len) => {
                     let len = match len.val {
-                        mir::interpret::ConstValue::Unevaluated(def_id, substs) => {
+                        ConstValue::Unevaluated(def_id, substs) => {
                             self.tcx.const_eval(self.tcx.param_env(def_id).and(GlobalId {
                                 instance: Instance::new(def_id, substs),
                                 promoted: None,