Handle custom discriminant values and detect invalid discriminants.

src/error.rs

@@ -5,6 +5,7 @@ use std::fmt;
 pub enum EvalError {
     DanglingPointerDeref,
     InvalidBool,
+    InvalidDiscriminant,
     PointerOutOfBounds,
     ReadPointerAsBytes,
     ReadBytesAsPointer,
@@ -21,6 +22,8 @@ impl Error for EvalError {
                 "dangling pointer was dereferenced",
             EvalError::InvalidBool =>
                 "invalid boolean value read",
+            EvalError::InvalidDiscriminant =>
+                "invalid enum discriminant value read",
             EvalError::PointerOutOfBounds =>
                 "pointer offset outside bounds of allocation",
             EvalError::ReadPointerAsBytes =>

src/interpreter.rs

@@ -228,7 +228,7 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
                 TerminatorTarget::Block(target_block)
             }
 
-            Switch { ref discr, ref targets, .. } => {
+            Switch { ref discr, ref targets, adt_def } => {
                 let adt_ptr = try!(self.eval_lvalue(discr)).to_ptr();
                 let adt_repr = self.lvalue_repr(discr);
                 let discr_size = match *adt_repr {
@@ -236,7 +236,14 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
                     _ => panic!("attmpted to switch on non-aggregate type"),
                 };
                 let discr_val = try!(self.memory.read_uint(adt_ptr, discr_size));
-                TerminatorTarget::Block(targets[discr_val as usize])
+
+                let matching = adt_def.variants.iter()
+                    .position(|v| discr_val == v.disr_val.to_u64_unchecked());
+
+                match matching {
+                    Some(i) => TerminatorTarget::Block(targets[i]),
+                    None => return Err(EvalError::InvalidDiscriminant),
+                }
             }
 
             Call { ref func, ref args, ref destination, .. } => {
@@ -481,13 +488,18 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
         Ok(TerminatorTarget::Call)
     }
 
-    fn assign_to_aggregate(&mut self, dest: Pointer, dest_repr: &Repr, variant: usize,
+    fn assign_to_aggregate(
-                         operands: &[mir::Operand<'tcx>]) -> EvalResult<()> {
+        &mut self,
+        dest: Pointer,
+        dest_repr: &Repr,
+        variant: usize,
+        discr: Option<u64>,
+        operands: &[mir::Operand<'tcx>],
+    ) -> EvalResult<()> {
         match *dest_repr {
             Repr::Aggregate { discr_size, ref variants, .. } => {
                 if discr_size > 0 {
-                    let discr = variant as u64;
+                    try!(self.memory.write_uint(dest, discr.unwrap(), discr_size));
-                    try!(self.memory.write_uint(dest, discr, discr_size));
                 }
                 let after_discr = dest.offset(discr_size as isize);
                 for (field, operand) in variants[variant].iter().zip(operands) {
@@ -538,10 +550,12 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
                 use rustc::mir::repr::AggregateKind::*;
                 match *kind {
                     Tuple | Closure(..) =>
-                        try!(self.assign_to_aggregate(dest, &dest_repr, 0, operands)),
+                        try!(self.assign_to_aggregate(dest, &dest_repr, 0, None, operands)),
 
-                    Adt(_, variant_idx, _) =>
+                    Adt(adt_def, variant, _) => {
-                        try!(self.assign_to_aggregate(dest, &dest_repr, variant_idx, operands)),
+                        let discr = Some(adt_def.variants[variant].disr_val.to_u64_unchecked());
+                        try!(self.assign_to_aggregate(dest, &dest_repr, variant, discr, operands));
+                    }
 
                     Vec => if let Repr::Array { elem_size, length } = *dest_repr {
                         assert_eq!(length, operands.len());
@@ -668,7 +682,7 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
         use rustc::mir::tcx::LvalueTy;
         match self.mir().lvalue_ty(self.tcx, lvalue) {
             LvalueTy::Ty { ty } => self.ty_to_repr(ty),
-            LvalueTy::Downcast { ref adt_def, substs, variant_index } => {
+            LvalueTy::Downcast { adt_def, substs, variant_index } => {
                 let field_tys = adt_def.variants[variant_index].fields.iter()
                     .map(|f| f.ty(self.tcx, substs));
                 self.repr_arena.alloc(self.make_aggregate_repr(iter::once(field_tys)))

test/c_enums.rs

@@ -0,0 +1,21 @@
+#![feature(custom_attribute)]
+#![allow(dead_code, unused_attributes)]
+
+enum Foo {
+    Bar = 42,
+    Baz,
+    Quux = 100,
+}
+
+#[miri_run]
+fn foo() -> [u8; 3] {
+    [Foo::Bar as u8, Foo::Baz as u8, Foo::Quux as u8]
+}
+
+#[miri_run]
+fn unsafe_match() -> bool {
+    match unsafe { std::mem::transmute::<u8, Foo>(43) } {
+        Foo::Baz => true,
+        _ => false,
+    }
+}