Merge pull request #373 from bjorn3/alloc_fix

Alloc api fix and tmp disable validation_op because of ICE

Author: oli-obk

miri/fn_call.rs

@@ -626,7 +626,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
 
         match &path[..] {
             // Allocators are magic.  They have no MIR, even when the rest of libstd does.
-            "alloc::heap::::__rust_alloc" => {
+            "alloc::alloc::::__rust_alloc" => {
                 let size = self.value_to_primval(args[0])?.to_u64()?;
                 let align = self.value_to_primval(args[1])?.to_u64()?;
                 if size == 0 {
@@ -640,7 +640,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                                                Some(MemoryKind::Rust.into()))?;
                 self.write_primval(dest, PrimVal::Ptr(ptr), dest_ty)?;
             }
-            "alloc::heap::::__rust_alloc_zeroed" => {
+            "alloc::alloc::::__rust_alloc_zeroed" => {
                 let size = self.value_to_primval(args[0])?.to_u64()?;
                 let align = self.value_to_primval(args[1])?.to_u64()?;
                 if size == 0 {
@@ -655,7 +655,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                 self.memory.write_repeat(ptr.into(), 0, size)?;
                 self.write_primval(dest, PrimVal::Ptr(ptr), dest_ty)?;
             }
-            "alloc::heap::::__rust_dealloc" => {
+            "alloc::alloc::::__rust_dealloc" => {
                 let ptr = self.into_ptr(args[0].value)?.to_ptr()?;
                 let old_size = self.value_to_primval(args[1])?.to_u64()?;
                 let align = self.value_to_primval(args[2])?.to_u64()?;
@@ -671,27 +671,23 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                     MemoryKind::Rust.into(),
                 )?;
             }
-            "alloc::heap::::__rust_realloc" => {
+            "alloc::alloc::::__rust_realloc" => {
                 let ptr = self.into_ptr(args[0].value)?.to_ptr()?;
                 let old_size = self.value_to_primval(args[1])?.to_u64()?;
-                let old_align = self.value_to_primval(args[2])?.to_u64()?;
+                let align = self.value_to_primval(args[2])?.to_u64()?;
                 let new_size = self.value_to_primval(args[3])?.to_u64()?;
-                let new_align = self.value_to_primval(args[4])?.to_u64()?;
                 if old_size == 0 || new_size == 0 {
                     return err!(HeapAllocZeroBytes);
                 }
-                if !old_align.is_power_of_two() {
-                    return err!(HeapAllocNonPowerOfTwoAlignment(old_align));
-                }
-                if !new_align.is_power_of_two() {
-                    return err!(HeapAllocNonPowerOfTwoAlignment(new_align));
+                if !align.is_power_of_two() {
+                    return err!(HeapAllocNonPowerOfTwoAlignment(align));
                 }
                 let new_ptr = self.memory.reallocate(
                     ptr,
                     old_size,
-                    Align::from_bytes(old_align, old_align).unwrap(),
+                    Align::from_bytes(align, align).unwrap(),
                     new_size,
-                    Align::from_bytes(new_align, new_align).unwrap(),
+                    Align::from_bytes(align, align).unwrap(),
                     MemoryKind::Rust.into(),
                 )?;
                 self.write_primval(dest, PrimVal::Ptr(new_ptr), dest_ty)?;

miri/lib.rs

@@ -448,6 +448,8 @@ impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         op: ::rustc::mir::ValidationOp,
         operand: &::rustc::mir::ValidationOperand<'tcx, ::rustc::mir::Place<'tcx>>,
     ) -> EvalResult<'tcx> {
-        ecx.validation_op(op, operand)
+        // FIXME: prevent this from ICEing
+        //ecx.validation_op(op, operand)
+        Ok(())
     }
 }