src/librustc_mir/interpret/operator.rs

   1 use rustc::mir;
   2 use rustc::ty::{self, Ty, layout};
   3 use syntax::ast::FloatTy;
   4 use rustc::ty::layout::LayoutOf;
   5 use rustc_apfloat::ieee::{Double, Single};
   6 use rustc_apfloat::Float;
   7
   8 use super::{EvalContext, Place, Machine, ValTy};
   9
  10 use rustc::mir::interpret::{EvalResult, Scalar, Value};
  11
  12 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
  13     fn binop_with_overflow(
  14         &mut self,
  15         op: mir::BinOp,
  16         left: ValTy<'tcx>,
  17         right: ValTy<'tcx>,
  18     ) -> EvalResult<'tcx, (Scalar, bool)> {
  19         let left_val = self.value_to_scalar(left)?;
  20         let right_val = self.value_to_scalar(right)?;
  21         self.binary_op(op, left_val, left.ty, right_val, right.ty)
  22     }
  23
  24     /// Applies the binary operation `op` to the two operands and writes a tuple of the result
  25     /// and a boolean signifying the potential overflow to the destination.
  26     pub fn intrinsic_with_overflow(
  27         &mut self,
  28         op: mir::BinOp,
  29         left: ValTy<'tcx>,
  30         right: ValTy<'tcx>,
  31         dest: Place,
  32         dest_ty: Ty<'tcx>,
  33     ) -> EvalResult<'tcx> {
  34         let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
  35         let val = Value::ScalarPair(val, Scalar::from_bool(overflowed));
  36         let valty = ValTy {
  37             value: val,
  38             ty: dest_ty,
  39         };
  40         self.write_value(valty, dest)
  41     }
  42
  43     /// Applies the binary operation `op` to the arguments and writes the result to the
  44     /// destination. Returns `true` if the operation overflowed.
  45     pub fn intrinsic_overflowing(
  46         &mut self,
  47         op: mir::BinOp,
  48         left: ValTy<'tcx>,
  49         right: ValTy<'tcx>,
  50         dest: Place,
  51         dest_ty: Ty<'tcx>,
  52     ) -> EvalResult<'tcx, bool> {
  53         let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
  54         self.write_scalar(dest, val, dest_ty)?;
  55         Ok(overflowed)
  56     }
  57 }
  58
  59 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
  60     /// Returns the result of the specified operation and whether it overflowed.
  61     pub fn binary_op(
  62         &self,
  63         bin_op: mir::BinOp,
  64         left: Scalar,
  65         left_ty: Ty<'tcx>,
  66         right: Scalar,
  67         right_ty: Ty<'tcx>,
  68     ) -> EvalResult<'tcx, (Scalar, bool)> {
  69         use rustc::mir::BinOp::*;
  70
  71         let left_layout = self.layout_of(left_ty)?;
  72         let right_layout = self.layout_of(right_ty)?;
  73
  74         let left_kind = match left_layout.abi {
  75             layout::Abi::Scalar(ref scalar) => scalar.value,
  76             _ => return err!(TypeNotPrimitive(left_ty)),
  77         };
  78         let right_kind = match right_layout.abi {
  79             layout::Abi::Scalar(ref scalar) => scalar.value,
  80             _ => return err!(TypeNotPrimitive(right_ty)),
  81         };
  82         trace!("Running binary op {:?}: {:?} ({:?}), {:?} ({:?})", bin_op, left, left_kind, right, right_kind);
  83
  84         // I: Handle operations that support pointers
  85         if !left_kind.is_float() && !right_kind.is_float() {
  86             if let Some(handled) = M::try_ptr_op(self, bin_op, left, left_ty, right, right_ty)? {
  87                 return Ok(handled);
  88             }
  89         }
  90
  91         // II: From now on, everything must be bytes, no pointers
  92         let l = left.to_bits(left_layout.size)?;
  93         let r = right.to_bits(right_layout.size)?;
  94
  95         // These ops can have an RHS with a different numeric type.
  96         if right_kind.is_int() && (bin_op == Shl || bin_op == Shr) {
  97             let signed = left_layout.abi.is_signed();
  98             let mut oflo = (r as u32 as u128) != r;
  99             let mut r = r as u32;
 100             let size = left_layout.size.bits() as u32;
 101             oflo |= r >= size;
 102             if oflo {
 103                 r %= size;
 104             }
 105             let result = if signed {
 106                 let l = self.sign_extend(l, left_ty)? as i128;
 107                 let result = match bin_op {
 108                     Shl => l << r,
 109                     Shr => l >> r,
 110                     _ => bug!("it has already been checked that this is a shift op"),
 111                 };
 112                 result as u128
 113             } else {
 114                 match bin_op {
 115                     Shl => l << r,
 116                     Shr => l >> r,
 117                     _ => bug!("it has already been checked that this is a shift op"),
 118                 }
 119             };
 120             let truncated = self.truncate(result, left_ty)?;
 121             return Ok((Scalar::Bits {
 122                 bits: truncated,
 123                 defined: size as u8,
 124             }, oflo));
 125         }
 126
 127         if left_kind != right_kind {
 128             let msg = format!(
 129                 "unimplemented binary op {:?}: {:?} ({:?}), {:?} ({:?})",
 130                 bin_op,
 131                 left,
 132                 left_kind,
 133                 right,
 134                 right_kind
 135             );
 136             return err!(Unimplemented(msg));
 137         }
 138
 139         if left_layout.abi.is_signed() {
 140             let op: Option<fn(&i128, &i128) -> bool> = match bin_op {
 141                 Lt => Some(i128::lt),
 142                 Le => Some(i128::le),
 143                 Gt => Some(i128::gt),
 144                 Ge => Some(i128::ge),
 145                 _ => None,
 146             };
 147             if let Some(op) = op {
 148                 let l = self.sign_extend(l, left_ty)? as i128;
 149                 let r = self.sign_extend(r, right_ty)? as i128;
 150                 return Ok((Scalar::from_bool(op(&l, &r)), false));
 151             }
 152             let op: Option<fn(i128, i128) -> (i128, bool)> = match bin_op {
 153                 Div if r == 0 => return err!(DivisionByZero),
 154                 Rem if r == 0 => return err!(RemainderByZero),
 155                 Div => Some(i128::overflowing_div),
 156                 Rem => Some(i128::overflowing_rem),
 157                 Add => Some(i128::overflowing_add),
 158                 Sub => Some(i128::overflowing_sub),
 159                 Mul => Some(i128::overflowing_mul),
 160                 _ => None,
 161             };
 162             if let Some(op) = op {
 163                 let l128 = self.sign_extend(l, left_ty)? as i128;
 164                 let r = self.sign_extend(r, right_ty)? as i128;
 165                 let size = left_layout.size.bits();
 166                 match bin_op {
 167                     Rem | Div => {
 168                         // int_min / -1
 169                         if r == -1 && l == (1 << (size - 1)) {
 170                             return Ok((Scalar::Bits { bits: l, defined: size as u8 }, true));
 171                         }
 172                     },
 173                     _ => {},
 174                 }
 175                 trace!("{}, {}, {}", l, l128, r);
 176                 let (result, mut oflo) = op(l128, r);
 177                 trace!("{}, {}", result, oflo);
 178                 if !oflo && size != 128 {
 179                     let max = 1 << (size - 1);
 180                     oflo = result >= max || result < -max;
 181                 }
 182                 let result = result as u128;
 183                 let truncated = self.truncate(result, left_ty)?;
 184                 return Ok((Scalar::Bits {
 185                     bits: truncated,
 186                     defined: size as u8,
 187                 }, oflo));
 188             }
 189         }
 190
 191         if let ty::TyFloat(fty) = left_ty.sty {
 192             macro_rules! float_math {
 193                 ($ty:path, $bitsize:expr) => {{
 194                     let l = <$ty>::from_bits(l);
 195                     let r = <$ty>::from_bits(r);
 196                     let bitify = |res: ::rustc_apfloat::StatusAnd<$ty>| Scalar::Bits {
 197                         bits: res.value.to_bits(),
 198                         defined: $bitsize,
 199                     };
 200                     let val = match bin_op {
 201                         Eq => Scalar::from_bool(l == r),
 202                         Ne => Scalar::from_bool(l != r),
 203                         Lt => Scalar::from_bool(l < r),
 204                         Le => Scalar::from_bool(l <= r),
 205                         Gt => Scalar::from_bool(l > r),
 206                         Ge => Scalar::from_bool(l >= r),
 207                         Add => bitify(l + r),
 208                         Sub => bitify(l - r),
 209                         Mul => bitify(l * r),
 210                         Div => bitify(l / r),
 211                         Rem => bitify(l % r),
 212                         _ => bug!("invalid float op: `{:?}`", bin_op),
 213                     };
 214                     return Ok((val, false));
 215                 }};
 216             }
 217             match fty {
 218                 FloatTy::F32 => float_math!(Single, 32),
 219                 FloatTy::F64 => float_math!(Double, 64),
 220             }
 221         }
 222
 223         let bit_width = self.layout_of(left_ty).unwrap().size.bits() as u8;
 224
 225         // only ints left
 226         let val = match bin_op {
 227             Eq => Scalar::from_bool(l == r),
 228             Ne => Scalar::from_bool(l != r),
 229
 230             Lt => Scalar::from_bool(l < r),
 231             Le => Scalar::from_bool(l <= r),
 232             Gt => Scalar::from_bool(l > r),
 233             Ge => Scalar::from_bool(l >= r),
 234
 235             BitOr => Scalar::Bits { bits: l | r, defined: bit_width },
 236             BitAnd => Scalar::Bits { bits: l & r, defined: bit_width },
 237             BitXor => Scalar::Bits { bits: l ^ r, defined: bit_width },
 238
 239             Add | Sub | Mul | Rem | Div => {
 240                 let op: fn(u128, u128) -> (u128, bool) = match bin_op {
 241                     Add => u128::overflowing_add,
 242                     Sub => u128::overflowing_sub,
 243                     Mul => u128::overflowing_mul,
 244                     Div if r == 0 => return err!(DivisionByZero),
 245                     Rem if r == 0 => return err!(RemainderByZero),
 246                     Div => u128::overflowing_div,
 247                     Rem => u128::overflowing_rem,
 248                     _ => bug!(),
 249                 };
 250                 let (result, oflo) = op(l, r);
 251                 let truncated = self.truncate(result, left_ty)?;
 252                 return Ok((Scalar::Bits {
 253                     bits: truncated,
 254                     defined: bit_width,
 255                 }, oflo || truncated != result));
 256             }
 257
 258             _ => {
 259                 let msg = format!(
 260                     "unimplemented binary op {:?}: {:?} ({:?}), {:?} ({:?})",
 261                     bin_op,
 262                     left,
 263                     left_ty,
 264                     right,
 265                     right_ty,
 266                 );
 267                 return err!(Unimplemented(msg));
 268             }
 269         };
 270
 271         Ok((val, false))
 272     }
 273
 274     pub fn unary_op(
 275         &self,
 276         un_op: mir::UnOp,
 277         val: Scalar,
 278         ty: Ty<'tcx>,
 279     ) -> EvalResult<'tcx, Scalar> {
 280         use rustc::mir::UnOp::*;
 281         use rustc_apfloat::ieee::{Single, Double};
 282         use rustc_apfloat::Float;
 283
 284         let size = self.layout_of(ty)?.size;
 285         let bytes = val.to_bits(size)?;
 286         let size = size.bits();
 287
 288         let result_bytes = match (un_op, &ty.sty) {
 289
 290             (Not, ty::TyBool) => !val.to_bool()? as u128,
 291
 292             (Not, _) => !bytes,
 293
 294             (Neg, ty::TyFloat(FloatTy::F32)) => Single::to_bits(-Single::from_bits(bytes)),
 295             (Neg, ty::TyFloat(FloatTy::F64)) => Double::to_bits(-Double::from_bits(bytes)),
 296
 297             (Neg, _) if bytes == (1 << (size - 1)) => return err!(OverflowNeg),
 298             (Neg, _) => (-(bytes as i128)) as u128,
 299         };
 300
 301         Ok(Scalar::Bits {
 302             bits: self.truncate(result_bytes, ty)?,
 303             defined: size as u8,
 304         })
 305     }
 306 }