From: Scott Olson <scott@solson.me>
Date: Mon, 9 May 2016 01:29:00 +0000 (-0600)
Subject: Handle CEnum layouts with unsigned representations.
X-Git-Url: https://git.lizzy.rs/?a=commitdiff_plain;h=d288472b297c4df82f293d2a8ea9c7098e3a70b3;p=rust.git

Handle CEnum layouts with unsigned representations.
---

diff --git a/src/interpreter.rs b/src/interpreter.rs
index 4ab2413e0ff..fe327b75452 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -258,7 +258,7 @@ fn eval_terminator(&mut self, terminator: &mir::Terminator<'tcx>)
                 let adt_layout = self.type_layout(self.lvalue_ty(discr));
 
                  match *adt_layout {
-                    Layout::General { discr, .. } => {
+                    Layout::General { discr, .. } | Layout::CEnum { discr, .. } => {
                         let discr_size = discr.size().bytes();
                         let discr_val = try!(self.memory.read_uint(adt_ptr, discr_size as usize));
 
@@ -283,7 +283,7 @@ fn eval_terminator(&mut self, terminator: &mir::Terminator<'tcx>)
                         TerminatorTarget::Block(targets[target as usize])
                     }
 
-                    _ => panic!("attmpted to switch on non-aggregate type"),
+                    _ => panic!("attempted to switch on non-aggregate type"),
                 }
             }
 
@@ -639,14 +639,15 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
             }
 
             Aggregate(ref kind, ref operands) => {
+                use rustc::ty::layout::Layout::*;
                 match *dest_layout {
-                    Layout::Univariant { ref variant, .. } => {
+                    Univariant { ref variant, .. } => {
                         let offsets = iter::once(0)
                             .chain(variant.offset_after_field.iter().map(|s| s.bytes()));
                         try!(self.assign_fields(dest, offsets, operands));
                     }
 
-                    Layout::Array { .. } => {
+                    Array { .. } => {
                         let elem_size = match dest_ty.sty {
                             ty::TyArray(elem_ty, _) => self.type_size(elem_ty) as u64,
                             _ => panic!("tried to assign {:?} to non-array type {:?}",
@@ -656,7 +657,7 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
                         try!(self.assign_fields(dest, offsets, operands));
                     }
 
-                    Layout::General { discr, ref variants, .. } => {
+                    General { discr, ref variants, .. } => {
                         if let mir::AggregateKind::Adt(adt_def, variant, _) = *kind {
                             let discr_val = adt_def.variants[variant].disr_val.to_u64_unchecked();
                             let discr_size = discr.size().bytes() as usize;
@@ -670,7 +671,7 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
                         }
                     }
 
-                    Layout::RawNullablePointer { nndiscr, .. } => {
+                    RawNullablePointer { nndiscr, .. } => {
                         if let mir::AggregateKind::Adt(_, variant, _) = *kind {
                             if nndiscr == variant as u64 {
                                 assert_eq!(operands.len(), 1);
@@ -687,6 +688,21 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
                         }
                     }
 
+                    CEnum { discr, signed, min, max } => {
+                        assert_eq!(operands.len(), 0);
+                        if let mir::AggregateKind::Adt(adt_def, variant, _) = *kind {
+                            if signed {
+                                unimplemented!()
+                            } else {
+                                let val = adt_def.variants[variant].disr_val.to_u64().unwrap();
+                                let size = discr.size().bytes() as usize;
+                                try!(self.memory.write_uint(dest, val, size));
+                            }
+                        } else {
+                            panic!("tried to assign {:?} to Layout::CEnum", kind);
+                        }
+                    }
+
                     _ => panic!("can't handle destination layout {:?} when assigning {:?}",
                                 dest_layout, kind),
                 }