Some cleanups

Author: bjorn3

miri/fn_call.rs

@@ -115,9 +115,9 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                 match ret_ty.sty {
                     ty::TyAdt(ref adt_def, _) => {
                         assert!(adt_def.is_enum(), "Unexpected return type for {}", item_path);
-                        let none_variant_index = adt_def.variants.iter().enumerate().find(|&(_i, ref def)| {
+                        let none_variant_index = adt_def.variants.iter().position(|def| {
                             def.name.as_str() == "None"
-                        }).expect("No None variant").0;
+                        }).expect("No None variant");
                         let (return_place, return_to_block) = destination.unwrap();
                         write_discriminant_value(self, ret_ty, return_place, none_variant_index)?;
                         self.goto_block(return_to_block);
@@ -126,12 +126,6 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                     _ => panic!("Unexpected return type for {}", item_path)
                 }
             }
-            "std::sys_common::thread_info::set" | "std::sys_common::cleanup" => {
-                // TODO rustc creates invalid mir inside std::cell::BorrowRef::new which is used by this function
-                let (_return_place, return_to_block) = destination.unwrap();
-                self.goto_block(return_to_block);
-                return Ok(true);
-            }
             "std::sys::unix::fast_thread_local::register_dtor" => {
                 // TODO: register the dtor
                 let (_return_place, return_to_block) = destination.unwrap();
@@ -465,17 +459,8 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
                             instance,
                             promoted: None,
                         };
-                        // compute global if not cached
-                        let value: Value = match self.tcx.interpret_interner.get_cached(instance.def_id()) {
-                            Some(ptr) => {
-                                Value::ByRef(MemoryPointer::new(ptr, 0).into(), name_align)
-                            }
-                            None => {
-                                let res: Option<(Value, Pointer, Ty)> = eval_body(self.tcx.tcx, cid, ty::ParamEnv::reveal_all());
-                                res.ok_or_else(||EvalErrorKind::MachineError("<already reported>".to_string()))?.0
-                            },
-                        };
-                        let value = self.value_to_primval(ValTy { value, ty: args[0].ty })?.to_u64()?;
+                        let const_val = self.const_eval(cid)?;
+                        let value = const_val.val.unwrap_u64();
                         if value == name {
                             result = Some(path_value);
                             break;

miri/intrinsic.rs

@@ -217,16 +217,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
                     // Also see the write_bytes intrinsic.
                     let elem_align = elem_layout.align;
                     let src = self.into_ptr(args[0].value)?;
-                    //let src_align = self.layout_of(args[0].ty)?.align;
-                    //let src_align = ty::layout::Align::from_bytes(1, 1).unwrap();
                     let dest = self.into_ptr(args[1].value)?;
-                    /*self.tcx.sess.warn(&format!("src_ty: {:?} src_align: {} elem_align: {} src_aligned: {:?} dst_aligned: {:?}",
-                        args[0].ty,
-                        src_align.abi(),
-                        elem_align.abi(),
-                        self.memory.check_align(src, src_align),
-                        self.memory.check_align(dest, elem_align)
-                    ));*/
                     self.memory.copy(
                         src,
                         elem_align,
@@ -360,7 +351,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
                         align: _align,
                         extra: PlaceExtra::None,
                     } => self.memory.write_repeat(ptr, 0, size)?,
-                    _ => bug!("TODO"),
+                    Place::Ptr { .. } => {
+                        bug!("init intrinsic tried to write to fat or unaligned ptr target")
+                    }
                 }
             }
 
@@ -637,7 +630,9 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super:
                         align: _align,
                         extra: PlaceExtra::None,
                     } => self.memory.mark_definedness(ptr, size, false)?,
-                    _ => bug!("todo"),
+                    Place::Ptr { .. } => {
+                        bug!("uninit intrinsic tried to write to fat or unaligned ptr target")
+                    }
                 }
             }
 

miri/lib.rs

@@ -210,7 +210,7 @@ pub struct MemoryData<'tcx> {
     /// The entry is created when allocating the memory and deleted after deallocation.
     locks: HashMap<AllocId, RangeMap<LockInfo<'tcx>>>,
 
-    mut_statics: HashMap<GlobalId<'tcx>, AllocId>,
+    statics: HashMap<GlobalId<'tcx>, AllocId>,
 }
 
 impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for Evaluator<'tcx> {
@@ -252,25 +252,24 @@ impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     }
 
     fn mark_static_initialized<'a>(
-        _mem: &mut Memory<'a, 'mir, 'tcx, Self>,
-        _id: AllocId,
+        mem: &mut Memory<'a, 'mir, 'tcx, Self>,
+        id: AllocId,
         _mutability: Mutability,
     ) -> EvalResult<'tcx, bool> {
-        /*use memory::MemoryKind::*;
-        match m {
+        use memory::MemoryKind::*;
+        match mem.get_alloc_kind(id) {
             // FIXME: This could be allowed, but not for env vars set during miri execution
-            Env => err!(Unimplemented("statics can't refer to env vars".to_owned())),
+            Some(MemoryKind::Machine(Env)) => err!(Unimplemented("statics can't refer to env vars".to_owned())),
             _ => Ok(false), // TODO: What does the bool mean?
-        }*/
-        Ok(false)
+        }
     }
 
     fn init_static<'a>(
         ecx: &mut EvalContext<'a, 'mir, 'tcx, Self>,
         cid: GlobalId<'tcx>,
     ) -> EvalResult<'tcx, AllocId> {
         // Step 1: If the static has already been evaluated return the cached version
-        if let Some(alloc_id) = ecx.memory.data.mut_statics.get(&cid) {
+        if let Some(alloc_id) = ecx.memory.data.statics.get(&cid) {
             return Ok(*alloc_id);
         }
 
@@ -293,7 +292,7 @@ impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         )?;
 
         // Step 4: Cache allocation id for recursive statics
-        assert!(ecx.memory.data.mut_statics.insert(cid, ptr.alloc_id).is_none());
+        assert!(ecx.memory.data.statics.insert(cid, ptr.alloc_id).is_none());
 
         // Step 5: Push stackframe to evaluate static
         let cleanup = StackPopCleanup::None;
@@ -325,6 +324,8 @@ impl<'mir, 'tcx: 'mir> Machine<'mir, 'tcx> for Evaluator<'tcx> {
             }
         }
 
+        // TODO: Freeze immutable statics without copying them to the global static cache
+
         // Step 7: Return the alloc
         Ok(ptr.alloc_id)
     }

miri/validation.rs

@@ -560,7 +560,7 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx> for EvalContext<'a, 'mir, '
             TyAdt(adt, _) if adt.is_box() => true,
             TySlice(_) | TyAdt(_, _) | TyTuple(..) | TyClosure(..) | TyArray(..) |
             TyDynamic(..) | TyGenerator(..) | TyForeign(_) => false,
-            TyGeneratorWitness(..) => bug!("I'm not sure what to return here"),
+            TyGeneratorWitness(..) => unreachable!("TyGeneratorWitness in validate"),
             TyParam(_) | TyInfer(_) | TyProjection(_) | TyAnon(..) | TyError => {
                 bug!("I got an incomplete/unnormalized type for validation")
             }

rust-toolchain

@@ -0,0 +1 @@
+nightly