]>
Commit | Line | Data |
---|---|---|
ea8adc8c | 1 | use rustc::mir; |
e1599b0c | 2 | use rustc::ty::{self, Ty, layout::{TyLayout, LayoutOf}}; |
ea8adc8c | 3 | use syntax::ast::FloatTy; |
83c7162d | 4 | use rustc_apfloat::Float; |
dc9dc135 | 5 | use rustc::mir::interpret::{InterpResult, Scalar}; |
ea8adc8c | 6 | |
416331ca | 7 | use super::{InterpCx, PlaceTy, Immediate, Machine, ImmTy}; |
ea8adc8c | 8 | |
ea8adc8c | 9 | |
416331ca | 10 | impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { |
ea8adc8c XL |
11 | /// Applies the binary operation `op` to the two operands and writes a tuple of the result |
12 | /// and a boolean signifying the potential overflow to the destination. | |
b7449926 | 13 | pub fn binop_with_overflow( |
ea8adc8c XL |
14 | &mut self, |
15 | op: mir::BinOp, | |
a1dfa0c6 XL |
16 | left: ImmTy<'tcx, M::PointerTag>, |
17 | right: ImmTy<'tcx, M::PointerTag>, | |
0bf4aa26 | 18 | dest: PlaceTy<'tcx, M::PointerTag>, |
dc9dc135 | 19 | ) -> InterpResult<'tcx> { |
e1599b0c XL |
20 | let (val, overflowed, ty) = self.overflowing_binary_op(op, left, right)?; |
21 | debug_assert_eq!( | |
22 | self.tcx.intern_tup(&[ty, self.tcx.types.bool]), | |
23 | dest.layout.ty, | |
24 | "type mismatch for result of {:?}", op, | |
25 | ); | |
a1dfa0c6 XL |
26 | let val = Immediate::ScalarPair(val.into(), Scalar::from_bool(overflowed).into()); |
27 | self.write_immediate(val, dest) | |
ea8adc8c XL |
28 | } |
29 | ||
30 | /// Applies the binary operation `op` to the arguments and writes the result to the | |
b7449926 XL |
31 | /// destination. |
32 | pub fn binop_ignore_overflow( | |
ea8adc8c XL |
33 | &mut self, |
34 | op: mir::BinOp, | |
a1dfa0c6 XL |
35 | left: ImmTy<'tcx, M::PointerTag>, |
36 | right: ImmTy<'tcx, M::PointerTag>, | |
0bf4aa26 | 37 | dest: PlaceTy<'tcx, M::PointerTag>, |
dc9dc135 | 38 | ) -> InterpResult<'tcx> { |
e1599b0c XL |
39 | let (val, _overflowed, ty) = self.overflowing_binary_op(op, left, right)?; |
40 | assert_eq!(ty, dest.layout.ty, "type mismatch for result of {:?}", op); | |
b7449926 | 41 | self.write_scalar(val, dest) |
ea8adc8c XL |
42 | } |
43 | } | |
44 | ||
416331ca | 45 | impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { |
b7449926 | 46 | fn binary_char_op( |
ea8adc8c XL |
47 | &self, |
48 | bin_op: mir::BinOp, | |
b7449926 XL |
49 | l: char, |
50 | r: char, | |
e1599b0c | 51 | ) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>) { |
ea8adc8c | 52 | use rustc::mir::BinOp::*; |
ea8adc8c | 53 | |
b7449926 XL |
54 | let res = match bin_op { |
55 | Eq => l == r, | |
56 | Ne => l != r, | |
57 | Lt => l < r, | |
58 | Le => l <= r, | |
59 | Gt => l > r, | |
60 | Ge => l >= r, | |
61 | _ => bug!("Invalid operation on char: {:?}", bin_op), | |
94b46f34 | 62 | }; |
e1599b0c | 63 | return (Scalar::from_bool(res), false, self.tcx.types.bool); |
b7449926 XL |
64 | } |
65 | ||
66 | fn binary_bool_op( | |
67 | &self, | |
68 | bin_op: mir::BinOp, | |
69 | l: bool, | |
70 | r: bool, | |
e1599b0c | 71 | ) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>) { |
b7449926 XL |
72 | use rustc::mir::BinOp::*; |
73 | ||
74 | let res = match bin_op { | |
75 | Eq => l == r, | |
76 | Ne => l != r, | |
77 | Lt => l < r, | |
78 | Le => l <= r, | |
79 | Gt => l > r, | |
80 | Ge => l >= r, | |
81 | BitAnd => l & r, | |
82 | BitOr => l | r, | |
83 | BitXor => l ^ r, | |
84 | _ => bug!("Invalid operation on bool: {:?}", bin_op), | |
94b46f34 | 85 | }; |
e1599b0c | 86 | return (Scalar::from_bool(res), false, self.tcx.types.bool); |
b7449926 | 87 | } |
ea8adc8c | 88 | |
dc9dc135 | 89 | fn binary_float_op<F: Float + Into<Scalar<M::PointerTag>>>( |
b7449926 XL |
90 | &self, |
91 | bin_op: mir::BinOp, | |
e1599b0c | 92 | ty: Ty<'tcx>, |
dc9dc135 XL |
93 | l: F, |
94 | r: F, | |
e1599b0c | 95 | ) -> (Scalar<M::PointerTag>, bool, Ty<'tcx>) { |
b7449926 XL |
96 | use rustc::mir::BinOp::*; |
97 | ||
e1599b0c XL |
98 | let (val, ty) = match bin_op { |
99 | Eq => (Scalar::from_bool(l == r), self.tcx.types.bool), | |
100 | Ne => (Scalar::from_bool(l != r), self.tcx.types.bool), | |
101 | Lt => (Scalar::from_bool(l < r), self.tcx.types.bool), | |
102 | Le => (Scalar::from_bool(l <= r), self.tcx.types.bool), | |
103 | Gt => (Scalar::from_bool(l > r), self.tcx.types.bool), | |
104 | Ge => (Scalar::from_bool(l >= r), self.tcx.types.bool), | |
105 | Add => ((l + r).value.into(), ty), | |
106 | Sub => ((l - r).value.into(), ty), | |
107 | Mul => ((l * r).value.into(), ty), | |
108 | Div => ((l / r).value.into(), ty), | |
109 | Rem => ((l % r).value.into(), ty), | |
dc9dc135 XL |
110 | _ => bug!("invalid float op: `{:?}`", bin_op), |
111 | }; | |
e1599b0c | 112 | return (val, false, ty); |
b7449926 | 113 | } |
ea8adc8c | 114 | |
b7449926 XL |
115 | fn binary_int_op( |
116 | &self, | |
117 | bin_op: mir::BinOp, | |
118 | // passing in raw bits | |
119 | l: u128, | |
120 | left_layout: TyLayout<'tcx>, | |
121 | r: u128, | |
122 | right_layout: TyLayout<'tcx>, | |
e1599b0c | 123 | ) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)> { |
b7449926 | 124 | use rustc::mir::BinOp::*; |
0531ce1d | 125 | |
b7449926 XL |
126 | // Shift ops can have an RHS with a different numeric type. |
127 | if bin_op == Shl || bin_op == Shr { | |
0531ce1d | 128 | let signed = left_layout.abi.is_signed(); |
8faf50e0 | 129 | let mut oflo = (r as u32 as u128) != r; |
0531ce1d | 130 | let mut r = r as u32; |
b7449926 XL |
131 | let size = left_layout.size; |
132 | oflo |= r >= size.bits() as u32; | |
0531ce1d | 133 | if oflo { |
b7449926 | 134 | r %= size.bits() as u32; |
0531ce1d XL |
135 | } |
136 | let result = if signed { | |
b7449926 | 137 | let l = self.sign_extend(l, left_layout) as i128; |
0531ce1d XL |
138 | let result = match bin_op { |
139 | Shl => l << r, | |
140 | Shr => l >> r, | |
141 | _ => bug!("it has already been checked that this is a shift op"), | |
142 | }; | |
143 | result as u128 | |
144 | } else { | |
145 | match bin_op { | |
146 | Shl => l << r, | |
147 | Shr => l >> r, | |
148 | _ => bug!("it has already been checked that this is a shift op"), | |
149 | } | |
ea8adc8c | 150 | }; |
b7449926 | 151 | let truncated = self.truncate(result, left_layout); |
e1599b0c | 152 | return Ok((Scalar::from_uint(truncated, size), oflo, left_layout.ty)); |
ea8adc8c XL |
153 | } |
154 | ||
b7449926 XL |
155 | // For the remaining ops, the types must be the same on both sides |
156 | if left_layout.ty != right_layout.ty { | |
416331ca XL |
157 | bug!( |
158 | "invalid asymmetric binary op {:?}: {:?} ({:?}), {:?} ({:?})", | |
ea8adc8c | 159 | bin_op, |
416331ca XL |
160 | l, left_layout.ty, |
161 | r, right_layout.ty, | |
162 | ) | |
ea8adc8c XL |
163 | } |
164 | ||
b7449926 | 165 | // Operations that need special treatment for signed integers |
0531ce1d XL |
166 | if left_layout.abi.is_signed() { |
167 | let op: Option<fn(&i128, &i128) -> bool> = match bin_op { | |
168 | Lt => Some(i128::lt), | |
169 | Le => Some(i128::le), | |
170 | Gt => Some(i128::gt), | |
171 | Ge => Some(i128::ge), | |
172 | _ => None, | |
173 | }; | |
174 | if let Some(op) = op { | |
b7449926 XL |
175 | let l = self.sign_extend(l, left_layout) as i128; |
176 | let r = self.sign_extend(r, right_layout) as i128; | |
e1599b0c | 177 | return Ok((Scalar::from_bool(op(&l, &r)), false, self.tcx.types.bool)); |
0531ce1d XL |
178 | } |
179 | let op: Option<fn(i128, i128) -> (i128, bool)> = match bin_op { | |
60c5eb7d XL |
180 | Div if r == 0 => throw_ub!(DivisionByZero), |
181 | Rem if r == 0 => throw_ub!(RemainderByZero), | |
0531ce1d XL |
182 | Div => Some(i128::overflowing_div), |
183 | Rem => Some(i128::overflowing_rem), | |
184 | Add => Some(i128::overflowing_add), | |
185 | Sub => Some(i128::overflowing_sub), | |
186 | Mul => Some(i128::overflowing_mul), | |
187 | _ => None, | |
188 | }; | |
189 | if let Some(op) = op { | |
b7449926 XL |
190 | let l128 = self.sign_extend(l, left_layout) as i128; |
191 | let r = self.sign_extend(r, right_layout) as i128; | |
192 | let size = left_layout.size; | |
0531ce1d XL |
193 | match bin_op { |
194 | Rem | Div => { | |
195 | // int_min / -1 | |
b7449926 | 196 | if r == -1 && l == (1 << (size.bits() - 1)) { |
e1599b0c | 197 | return Ok((Scalar::from_uint(l, size), true, left_layout.ty)); |
0531ce1d XL |
198 | } |
199 | }, | |
200 | _ => {}, | |
201 | } | |
202 | trace!("{}, {}, {}", l, l128, r); | |
203 | let (result, mut oflo) = op(l128, r); | |
204 | trace!("{}, {}", result, oflo); | |
b7449926 XL |
205 | if !oflo && size.bits() != 128 { |
206 | let max = 1 << (size.bits() - 1); | |
0531ce1d XL |
207 | oflo = result >= max || result < -max; |
208 | } | |
b7449926 | 209 | // this may be out-of-bounds for the result type, so we have to truncate ourselves |
0531ce1d | 210 | let result = result as u128; |
b7449926 | 211 | let truncated = self.truncate(result, left_layout); |
e1599b0c | 212 | return Ok((Scalar::from_uint(truncated, size), oflo, left_layout.ty)); |
83c7162d | 213 | } |
0531ce1d | 214 | } |
ea8adc8c | 215 | |
b7449926 | 216 | let size = left_layout.size; |
94b46f34 | 217 | |
e1599b0c XL |
218 | let (val, ty) = match bin_op { |
219 | Eq => (Scalar::from_bool(l == r), self.tcx.types.bool), | |
220 | Ne => (Scalar::from_bool(l != r), self.tcx.types.bool), | |
0531ce1d | 221 | |
e1599b0c XL |
222 | Lt => (Scalar::from_bool(l < r), self.tcx.types.bool), |
223 | Le => (Scalar::from_bool(l <= r), self.tcx.types.bool), | |
224 | Gt => (Scalar::from_bool(l > r), self.tcx.types.bool), | |
225 | Ge => (Scalar::from_bool(l >= r), self.tcx.types.bool), | |
0531ce1d | 226 | |
e1599b0c XL |
227 | BitOr => (Scalar::from_uint(l | r, size), left_layout.ty), |
228 | BitAnd => (Scalar::from_uint(l & r, size), left_layout.ty), | |
229 | BitXor => (Scalar::from_uint(l ^ r, size), left_layout.ty), | |
0531ce1d XL |
230 | |
231 | Add | Sub | Mul | Rem | Div => { | |
b7449926 | 232 | debug_assert!(!left_layout.abi.is_signed()); |
0531ce1d XL |
233 | let op: fn(u128, u128) -> (u128, bool) = match bin_op { |
234 | Add => u128::overflowing_add, | |
235 | Sub => u128::overflowing_sub, | |
236 | Mul => u128::overflowing_mul, | |
60c5eb7d XL |
237 | Div if r == 0 => throw_ub!(DivisionByZero), |
238 | Rem if r == 0 => throw_ub!(RemainderByZero), | |
0531ce1d XL |
239 | Div => u128::overflowing_div, |
240 | Rem => u128::overflowing_rem, | |
241 | _ => bug!(), | |
242 | }; | |
243 | let (result, oflo) = op(l, r); | |
b7449926 | 244 | let truncated = self.truncate(result, left_layout); |
e1599b0c XL |
245 | return Ok(( |
246 | Scalar::from_uint(truncated, size), | |
247 | oflo || truncated != result, | |
248 | left_layout.ty, | |
249 | )); | |
0531ce1d | 250 | } |
ea8adc8c XL |
251 | |
252 | _ => { | |
416331ca XL |
253 | bug!( |
254 | "invalid binary op {:?}: {:?}, {:?} (both {:?})", | |
ea8adc8c | 255 | bin_op, |
b7449926 XL |
256 | l, |
257 | r, | |
258 | right_layout.ty, | |
416331ca | 259 | ) |
ea8adc8c XL |
260 | } |
261 | }; | |
262 | ||
e1599b0c | 263 | Ok((val, false, ty)) |
ea8adc8c | 264 | } |
ea8adc8c | 265 | |
e1599b0c XL |
266 | /// Returns the result of the specified operation, whether it overflowed, and |
267 | /// the result type. | |
268 | pub fn overflowing_binary_op( | |
b7449926 XL |
269 | &self, |
270 | bin_op: mir::BinOp, | |
a1dfa0c6 XL |
271 | left: ImmTy<'tcx, M::PointerTag>, |
272 | right: ImmTy<'tcx, M::PointerTag>, | |
e1599b0c | 273 | ) -> InterpResult<'tcx, (Scalar<M::PointerTag>, bool, Ty<'tcx>)> { |
b7449926 | 274 | trace!("Running binary op {:?}: {:?} ({:?}), {:?} ({:?})", |
9fa01778 | 275 | bin_op, *left, left.layout.ty, *right, right.layout.ty); |
b7449926 | 276 | |
e74abb32 | 277 | match left.layout.ty.kind { |
b7449926 | 278 | ty::Char => { |
9fa01778 | 279 | assert_eq!(left.layout.ty, right.layout.ty); |
dc9dc135 XL |
280 | let left = left.to_scalar()?; |
281 | let right = right.to_scalar()?; | |
282 | Ok(self.binary_char_op(bin_op, left.to_char()?, right.to_char()?)) | |
b7449926 XL |
283 | } |
284 | ty::Bool => { | |
9fa01778 | 285 | assert_eq!(left.layout.ty, right.layout.ty); |
dc9dc135 XL |
286 | let left = left.to_scalar()?; |
287 | let right = right.to_scalar()?; | |
288 | Ok(self.binary_bool_op(bin_op, left.to_bool()?, right.to_bool()?)) | |
b7449926 XL |
289 | } |
290 | ty::Float(fty) => { | |
9fa01778 | 291 | assert_eq!(left.layout.ty, right.layout.ty); |
e1599b0c | 292 | let ty = left.layout.ty; |
dc9dc135 XL |
293 | let left = left.to_scalar()?; |
294 | let right = right.to_scalar()?; | |
295 | Ok(match fty { | |
e1599b0c XL |
296 | FloatTy::F32 => |
297 | self.binary_float_op(bin_op, ty, left.to_f32()?, right.to_f32()?), | |
298 | FloatTy::F64 => | |
299 | self.binary_float_op(bin_op, ty, left.to_f64()?, right.to_f64()?), | |
dc9dc135 | 300 | }) |
b7449926 | 301 | } |
416331ca XL |
302 | _ if left.layout.ty.is_integral() => { |
303 | // the RHS type can be different, e.g. for shifts -- but it has to be integral, too | |
dc9dc135 | 304 | assert!( |
416331ca XL |
305 | right.layout.ty.is_integral(), |
306 | "Unexpected types for BinOp: {:?} {:?} {:?}", | |
307 | left.layout.ty, bin_op, right.layout.ty | |
308 | ); | |
b7449926 | 309 | |
416331ca XL |
310 | let l = self.force_bits(left.to_scalar()?, left.layout.size)?; |
311 | let r = self.force_bits(right.to_scalar()?, right.layout.size)?; | |
9fa01778 | 312 | self.binary_int_op(bin_op, l, left.layout, r, right.layout) |
b7449926 | 313 | } |
416331ca XL |
314 | _ if left.layout.ty.is_any_ptr() => { |
315 | // The RHS type must be the same *or an integer type* (for `Offset`). | |
316 | assert!( | |
317 | right.layout.ty == left.layout.ty || right.layout.ty.is_integral(), | |
318 | "Unexpected types for BinOp: {:?} {:?} {:?}", | |
319 | left.layout.ty, bin_op, right.layout.ty | |
320 | ); | |
321 | ||
322 | M::binary_ptr_op(self, bin_op, left, right) | |
323 | } | |
324 | _ => bug!("Invalid MIR: bad LHS type for binop: {:?}", left.layout.ty), | |
b7449926 XL |
325 | } |
326 | } | |
327 | ||
e1599b0c XL |
328 | /// Typed version of `checked_binary_op`, returning an `ImmTy`. Also ignores overflows. |
329 | #[inline] | |
330 | pub fn binary_op( | |
331 | &self, | |
332 | bin_op: mir::BinOp, | |
333 | left: ImmTy<'tcx, M::PointerTag>, | |
334 | right: ImmTy<'tcx, M::PointerTag>, | |
335 | ) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>> { | |
336 | let (val, _overflow, ty) = self.overflowing_binary_op(bin_op, left, right)?; | |
337 | Ok(ImmTy::from_scalar(val, self.layout_of(ty)?)) | |
338 | } | |
339 | ||
0531ce1d XL |
340 | pub fn unary_op( |
341 | &self, | |
342 | un_op: mir::UnOp, | |
9fa01778 | 343 | val: ImmTy<'tcx, M::PointerTag>, |
e1599b0c | 344 | ) -> InterpResult<'tcx, ImmTy<'tcx, M::PointerTag>> { |
0531ce1d | 345 | use rustc::mir::UnOp::*; |
ea8adc8c | 346 | |
9fa01778 XL |
347 | let layout = val.layout; |
348 | let val = val.to_scalar()?; | |
532ac7d7 | 349 | trace!("Running unary op {:?}: {:?} ({:?})", un_op, val, layout.ty); |
ea8adc8c | 350 | |
e74abb32 | 351 | match layout.ty.kind { |
b7449926 XL |
352 | ty::Bool => { |
353 | let val = val.to_bool()?; | |
354 | let res = match un_op { | |
355 | Not => !val, | |
356 | _ => bug!("Invalid bool op {:?}", un_op) | |
357 | }; | |
e1599b0c | 358 | Ok(ImmTy::from_scalar(Scalar::from_bool(res), self.layout_of(self.tcx.types.bool)?)) |
b7449926 XL |
359 | } |
360 | ty::Float(fty) => { | |
b7449926 | 361 | let res = match (un_op, fty) { |
dc9dc135 XL |
362 | (Neg, FloatTy::F32) => Scalar::from_f32(-val.to_f32()?), |
363 | (Neg, FloatTy::F64) => Scalar::from_f64(-val.to_f64()?), | |
b7449926 XL |
364 | _ => bug!("Invalid float op {:?}", un_op) |
365 | }; | |
e1599b0c | 366 | Ok(ImmTy::from_scalar(res, layout)) |
b7449926 XL |
367 | } |
368 | _ => { | |
369 | assert!(layout.ty.is_integral()); | |
dc9dc135 | 370 | let val = self.force_bits(val, layout.size)?; |
b7449926 XL |
371 | let res = match un_op { |
372 | Not => !val, | |
373 | Neg => { | |
374 | assert!(layout.abi.is_signed()); | |
375 | (-(val as i128)) as u128 | |
376 | } | |
377 | }; | |
378 | // res needs tuncating | |
e1599b0c | 379 | Ok(ImmTy::from_uint(self.truncate(res, layout), layout)) |
b7449926 XL |
380 | } |
381 | } | |
0531ce1d | 382 | } |
ea8adc8c | 383 | } |