Represent PrimVals as "bitbags".

Now instead of holding a native type based on the tag, all PrimVals
store a u64 (the `bits`), along with a `kind` corresponding to the
variant as it would be in the old PrimVal representation.

This commit makes no major optimizations and attempts to not change any
behaviour. There will be commits to follow that make use of this
representation to eliminate unnecessary allocation hacks like in
`value_to_primval`.

A number of places could be even more cleaned up after this commit,
particularly in `cast.rs`.

Author: solson

src/interpreter/cast.rs

@@ -8,96 +8,107 @@ use primval::PrimVal;
 use memory::Pointer;
 
 use rustc::ty::Ty;
-use syntax::ast::{self, IntTy, UintTy};
+use syntax::ast::{FloatTy, IntTy, UintTy};
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     pub(super) fn cast_primval(&self, val: PrimVal, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
-        use primval::PrimVal::*;
-        match val {
-            Bool(b) => self.cast_const_int(b as u64, ty, false),
-            F32(f) => self.cast_const_float(f as f64, ty),
-            F64(f) => self.cast_const_float(f, ty),
-            I8(i) => self.cast_signed_int(i as i64, ty),
-            I16(i) => self.cast_signed_int(i as i64, ty),
-            I32(i) => self.cast_signed_int(i as i64, ty),
-            I64(i) => self.cast_signed_int(i, ty),
-            U8(u) => self.cast_const_int(u as u64, ty, false),
-            U16(u) => self.cast_const_int(u as u64, ty, false),
-            U32(u) => self.cast_const_int(u as u64, ty, false),
-            Char(c) => self.cast_const_int(c as u64, ty, false),
-            U64(u) => self.cast_const_int(u, ty, false),
-            FnPtr(ptr) |
-            Ptr(ptr) => self.cast_ptr(ptr, ty),
-        }
-    }
+        use primval::PrimValKind::*;
+        match val.kind {
+            F32 => self.cast_float(val.to_f32() as f64, ty),
+            F64 => self.cast_float(val.to_f64(), ty),
 
-    fn cast_ptr(&self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
-        use primval::PrimVal::*;
-        match ty.sty {
-            ty::TyRef(..) |
-            ty::TyRawPtr(_) => Ok(Ptr(ptr)),
-            ty::TyFnPtr(_) => Ok(FnPtr(ptr)),
-            ty::TyInt(IntTy::I8) => Ok(I8(ptr.to_int()? as i8)),
-            ty::TyInt(IntTy::I16) => Ok(I16(ptr.to_int()? as i16)),
-            ty::TyInt(IntTy::I32) => Ok(I32(ptr.to_int()? as i32)),
-            ty::TyInt(IntTy::I64) => Ok(I64(ptr.to_int()? as i64)),
-            ty::TyUint(UintTy::U8) => Ok(U8(ptr.to_int()? as u8)),
-            ty::TyUint(UintTy::U16) => Ok(U16(ptr.to_int()? as u16)),
-            ty::TyUint(UintTy::U32) => Ok(U32(ptr.to_int()? as u32)),
-            ty::TyUint(UintTy::U64) => Ok(U64(ptr.to_int()? as u64)),
-            _ => Err(EvalError::Unimplemented(format!("ptr to {:?} cast", ty))),
+            I8 | I16 | I32 | I64 => self.cast_signed_int(val.bits as i64, ty),
+
+            Bool | Char | U8 | U16 | U32 | U64 => self.cast_int(val.bits, ty, false),
+
+            FnPtr(alloc) | Ptr(alloc) => {
+                let ptr = Pointer::new(alloc, val.bits as usize);
+                self.cast_ptr(ptr, ty)
+            }
         }
     }
 
     fn cast_signed_int(&self, val: i64, ty: ty::Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
-        self.cast_const_int(val as u64, ty, val < 0)
+        self.cast_int(val as u64, ty, val < 0)
     }
 
-    fn cast_const_int(&self, v: u64, ty: ty::Ty<'tcx>, negative: bool) -> EvalResult<'tcx, PrimVal> {
-        use primval::PrimVal::*;
+    fn cast_int(&self, v: u64, ty: ty::Ty<'tcx>, negative: bool) -> EvalResult<'tcx, PrimVal> {
+        use primval::PrimValKind::*;
+        use rustc::ty::TypeVariants::*;
         match ty.sty {
-            ty::TyBool if v == 0 => Ok(Bool(false)),
-            ty::TyBool if v == 1 => Ok(Bool(true)),
-            ty::TyBool => Err(EvalError::InvalidBool),
-            ty::TyInt(ast::IntTy::I8) => Ok(I8(v as i64 as i8)),
-            ty::TyInt(ast::IntTy::I16) => Ok(I16(v as i64 as i16)),
-            ty::TyInt(ast::IntTy::I32) => Ok(I32(v as i64 as i32)),
-            ty::TyInt(ast::IntTy::I64) => Ok(I64(v as i64)),
-            ty::TyInt(ast::IntTy::Is) => {
+            TyBool if v == 0 => Ok(PrimVal::from_bool(false)),
+            TyBool if v == 1 => Ok(PrimVal::from_bool(true)),
+            TyBool => Err(EvalError::InvalidBool),
+
+            TyInt(IntTy::I8)  => Ok(PrimVal::new(v as i64 as i8  as u64, I8)),
+            TyInt(IntTy::I16) => Ok(PrimVal::new(v as i64 as i16 as u64, I16)),
+            TyInt(IntTy::I32) => Ok(PrimVal::new(v as i64 as i32 as u64, I32)),
+            TyInt(IntTy::I64) => Ok(PrimVal::new(v as i64 as i64 as u64, I64)),
+
+            TyUint(UintTy::U8)  => Ok(PrimVal::new(v as u8  as u64, U8)),
+            TyUint(UintTy::U16) => Ok(PrimVal::new(v as u16 as u64, U16)),
+            TyUint(UintTy::U32) => Ok(PrimVal::new(v as u32 as u64, U32)),
+            TyUint(UintTy::U64) => Ok(PrimVal::new(v, U64)),
+
+            TyInt(IntTy::Is) => {
                 let int_ty = self.tcx.sess.target.int_type;
                 let ty = self.tcx.mk_mach_int(int_ty);
-                self.cast_const_int(v, ty, negative)
-            },
-            ty::TyUint(ast::UintTy::U8) => Ok(U8(v as u8)),
-            ty::TyUint(ast::UintTy::U16) => Ok(U16(v as u16)),
-            ty::TyUint(ast::UintTy::U32) => Ok(U32(v as u32)),
-            ty::TyUint(ast::UintTy::U64) => Ok(U64(v)),
-            ty::TyUint(ast::UintTy::Us) => {
+                self.cast_int(v, ty, negative)
+            }
+
+            TyUint(UintTy::Us) => {
                 let uint_ty = self.tcx.sess.target.uint_type;
                 let ty = self.tcx.mk_mach_uint(uint_ty);
-                self.cast_const_int(v, ty, negative)
-            },
-            ty::TyFloat(ast::FloatTy::F64) if negative => Ok(F64(v as i64 as f64)),
-            ty::TyFloat(ast::FloatTy::F64) => Ok(F64(v as f64)),
-            ty::TyFloat(ast::FloatTy::F32) if negative => Ok(F32(v as i64 as f32)),
-            ty::TyFloat(ast::FloatTy::F32) => Ok(F32(v as f32)),
-            ty::TyRawPtr(_) => Ok(Ptr(Pointer::from_int(v as usize))),
-            ty::TyChar if v as u8 as u64 == v => Ok(Char(v as u8 as char)),
-            ty::TyChar => Err(EvalError::InvalidChar(v)),
+                self.cast_int(v, ty, negative)
+            }
+
+            TyFloat(FloatTy::F64) if negative => Ok(PrimVal::from_f64(v as i64 as f64)),
+            TyFloat(FloatTy::F64)             => Ok(PrimVal::from_f64(v as f64)),
+            TyFloat(FloatTy::F32) if negative => Ok(PrimVal::from_f32(v as i64 as f32)),
+            TyFloat(FloatTy::F32)             => Ok(PrimVal::from_f32(v as f32)),
+
+            TyChar if v as u8 as u64 == v => Ok(PrimVal::new(v, Char)),
+            TyChar => Err(EvalError::InvalidChar(v)),
+
+            TyRawPtr(_) => Ok(PrimVal::from_ptr(Pointer::from_int(v as usize))),
+
             _ => Err(EvalError::Unimplemented(format!("int to {:?} cast", ty))),
         }
     }
 
-    fn cast_const_float(&self, val: f64, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
-        use primval::PrimVal::*;
+    fn cast_float(&self, val: f64, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
+        use rustc::ty::TypeVariants::*;
         match ty.sty {
-            // casting negative floats to unsigned integers yields zero
-            ty::TyUint(_) if val < 0.0 => self.cast_const_int(0, ty, false),
-            ty::TyInt(_) if val < 0.0 => self.cast_const_int(val as i64 as u64, ty, true),
-            ty::TyInt(_) | ty::TyUint(_) => self.cast_const_int(val as u64, ty, false),
-            ty::TyFloat(ast::FloatTy::F64) => Ok(F64(val)),
-            ty::TyFloat(ast::FloatTy::F32) => Ok(F32(val as f32)),
+            // Casting negative floats to unsigned integers yields zero.
+            TyUint(_) if val < 0.0 => self.cast_int(0, ty, false),
+            TyInt(_)  if val < 0.0 => self.cast_int(val as i64 as u64, ty, true),
+
+            TyInt(_) | ty::TyUint(_) => self.cast_int(val as u64, ty, false),
+
+            TyFloat(FloatTy::F64) => Ok(PrimVal::from_f64(val)),
+            TyFloat(FloatTy::F32) => Ok(PrimVal::from_f32(val as f32)),
             _ => Err(EvalError::Unimplemented(format!("float to {:?} cast", ty))),
         }
     }
+
+    fn cast_ptr(&self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
+        use primval::PrimValKind::*;
+        use rustc::ty::TypeVariants::*;
+        match ty.sty {
+            TyRef(..) | TyRawPtr(_) => Ok(PrimVal::from_ptr(ptr)),
+            TyFnPtr(_) => Ok(PrimVal::from_fn_ptr(ptr)),
+
+            TyInt(IntTy::I8)  => Ok(PrimVal::new(ptr.to_int()? as u64, I8)),
+            TyInt(IntTy::I16) => Ok(PrimVal::new(ptr.to_int()? as u64, I16)),
+            TyInt(IntTy::I32) => Ok(PrimVal::new(ptr.to_int()? as u64, I32)),
+            TyInt(IntTy::I64) => Ok(PrimVal::new(ptr.to_int()? as u64, I64)),
+
+            TyUint(UintTy::U8)  => Ok(PrimVal::new(ptr.to_int()? as u64, U8)),
+            TyUint(UintTy::U16) => Ok(PrimVal::new(ptr.to_int()? as u64, U16)),
+            TyUint(UintTy::U32) => Ok(PrimVal::new(ptr.to_int()? as u64, U32)),
+            TyUint(UintTy::U64) => Ok(PrimVal::new(ptr.to_int()? as u64, U64)),
+
+            _ => Err(EvalError::Unimplemented(format!("ptr to {:?} cast", ty))),
+        }
+    }
 }