src/librustc_mir/interpret/step.rs

   1 // Copyright 2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! This module contains the `EvalContext` methods for executing a single step of the interpreter.
  12 //!
  13 //! The main entry point is the `step` method.
  14
  15 use rustc::mir;
  16 use rustc::ty::layout::LayoutOf;
  17 use rustc::mir::interpret::{EvalResult, Scalar, PointerArithmetic};
  18
  19 use super::{EvalContext, Machine};
  20
  21 /// Classify whether an operator is "left-homogeneous", i.e. the LHS has the
  22 /// same type as the result.
  23 #[inline]
  24 fn binop_left_homogeneous(op: mir::BinOp) -> bool {
  25     use rustc::mir::BinOp::*;
  26     match op {
  27         Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr |
  28         Offset | Shl | Shr =>
  29             true,
  30         Eq | Ne | Lt | Le | Gt | Ge =>
  31             false,
  32     }
  33 }
  34 /// Classify whether an operator is "right-homogeneous", i.e. the RHS has the
  35 /// same type as the LHS.
  36 #[inline]
  37 fn binop_right_homogeneous(op: mir::BinOp) -> bool {
  38     use rustc::mir::BinOp::*;
  39     match op {
  40         Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr |
  41         Eq | Ne | Lt | Le | Gt | Ge =>
  42             true,
  43         Offset | Shl | Shr =>
  44             false,
  45     }
  46 }
  47
  48 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
  49     pub fn run(&mut self) -> EvalResult<'tcx> {
  50         while self.step()? {}
  51         Ok(())
  52     }
  53
  54     /// Returns true as long as there are more things to do.
  55     ///
  56     /// This is used by [priroda](https://github.com/oli-obk/priroda)
  57     pub fn step(&mut self) -> EvalResult<'tcx, bool> {
  58         if self.stack.is_empty() {
  59             return Ok(false);
  60         }
  61
  62         let block = self.frame().block;
  63         let stmt_id = self.frame().stmt;
  64         let mir = self.mir();
  65         let basic_block = &mir.basic_blocks()[block];
  66
  67         let old_frames = self.cur_frame();
  68
  69         if let Some(stmt) = basic_block.statements.get(stmt_id) {
  70             assert_eq!(old_frames, self.cur_frame());
  71             self.statement(stmt)?;
  72             return Ok(true);
  73         }
  74
  75         M::before_terminator(self)?;
  76
  77         let terminator = basic_block.terminator();
  78         assert_eq!(old_frames, self.cur_frame());
  79         self.terminator(terminator)?;
  80         Ok(true)
  81     }
  82
  83     fn statement(&mut self, stmt: &mir::Statement<'tcx>) -> EvalResult<'tcx> {
  84         debug!("{:?}", stmt);
  85
  86         use rustc::mir::StatementKind::*;
  87
  88         // Some statements (e.g. box) push new stack frames.
  89         // We have to record the stack frame number *before* executing the statement.
  90         let frame_idx = self.cur_frame();
  91         self.tcx.span = stmt.source_info.span;
  92         self.memory.tcx.span = stmt.source_info.span;
  93
  94         match stmt.kind {
  95             Assign(ref place, ref rvalue) => self.eval_rvalue_into_place(rvalue, place)?,
  96
  97             SetDiscriminant {
  98                 ref place,
  99                 variant_index,
 100             } => {
 101                 let dest = self.eval_place(place)?;
 102                 self.write_discriminant_index(variant_index, dest)?;
 103             }
 104
 105             // Mark locals as alive
 106             StorageLive(local) => {
 107                 let old_val = self.storage_live(local)?;
 108                 self.deallocate_local(old_val)?;
 109             }
 110
 111             // Mark locals as dead
 112             StorageDead(local) => {
 113                 let old_val = self.storage_dead(local);
 114                 self.deallocate_local(old_val)?;
 115             }
 116
 117             // No dynamic semantics attached to `FakeRead`; MIR
 118             // interpreter is solely intended for borrowck'ed code.
 119             FakeRead(..) => {}
 120
 121             // Stacked Borrows.
 122             Retag { fn_entry, ref place } => {
 123                 let dest = self.eval_place(place)?;
 124                 M::retag(self, fn_entry, dest)?;
 125             }
 126             EscapeToRaw(ref op) => {
 127                 let op = self.eval_operand(op, None)?;
 128                 M::escape_to_raw(self, op)?;
 129             }
 130
 131             // Statements we do not track.
 132             EndRegion(..) => {}
 133             AscribeUserType(..) => {}
 134
 135             // Defined to do nothing. These are added by optimization passes, to avoid changing the
 136             // size of MIR constantly.
 137             Nop => {}
 138
 139             InlineAsm { .. } => return err!(InlineAsm),
 140         }
 141
 142         self.stack[frame_idx].stmt += 1;
 143         Ok(())
 144     }
 145
 146     /// Evaluate an assignment statement.
 147     ///
 148     /// There is no separate `eval_rvalue` function. Instead, the code for handling each rvalue
 149     /// type writes its results directly into the memory specified by the place.
 150     fn eval_rvalue_into_place(
 151         &mut self,
 152         rvalue: &mir::Rvalue<'tcx>,
 153         place: &mir::Place<'tcx>,
 154     ) -> EvalResult<'tcx> {
 155         let dest = self.eval_place(place)?;
 156
 157         use rustc::mir::Rvalue::*;
 158         match *rvalue {
 159             Use(ref operand) => {
 160                 // Avoid recomputing the layout
 161                 let op = self.eval_operand(operand, Some(dest.layout))?;
 162                 self.copy_op(op, dest)?;
 163             }
 164
 165             BinaryOp(bin_op, ref left, ref right) => {
 166                 let layout = if binop_left_homogeneous(bin_op) { Some(dest.layout) } else { None };
 167                 let left = self.read_immediate(self.eval_operand(left, layout)?)?;
 168                 let layout = if binop_right_homogeneous(bin_op) { Some(left.layout) } else { None };
 169                 let right = self.read_immediate(self.eval_operand(right, layout)?)?;
 170                 self.binop_ignore_overflow(
 171                     bin_op,
 172                     left,
 173                     right,
 174                     dest,
 175                 )?;
 176             }
 177
 178             CheckedBinaryOp(bin_op, ref left, ref right) => {
 179                 // Due to the extra boolean in the result, we can never reuse the `dest.layout`.
 180                 let left = self.read_immediate(self.eval_operand(left, None)?)?;
 181                 let layout = if binop_right_homogeneous(bin_op) { Some(left.layout) } else { None };
 182                 let right = self.read_immediate(self.eval_operand(right, layout)?)?;
 183                 self.binop_with_overflow(
 184                     bin_op,
 185                     left,
 186                     right,
 187                     dest,
 188                 )?;
 189             }
 190
 191             UnaryOp(un_op, ref operand) => {
 192                 // The operand always has the same type as the result.
 193                 let val = self.read_immediate(self.eval_operand(operand, Some(dest.layout))?)?;
 194                 let val = self.unary_op(un_op, val.to_scalar()?, dest.layout)?;
 195                 self.write_scalar(val, dest)?;
 196             }
 197
 198             Aggregate(ref kind, ref operands) => {
 199                 let (dest, active_field_index) = match **kind {
 200                     mir::AggregateKind::Adt(adt_def, variant_index, _, _, active_field_index) => {
 201                         self.write_discriminant_index(variant_index, dest)?;
 202                         if adt_def.is_enum() {
 203                             (self.place_downcast(dest, variant_index)?, active_field_index)
 204                         } else {
 205                             (dest, active_field_index)
 206                         }
 207                     }
 208                     _ => (dest, None)
 209                 };
 210
 211                 for (i, operand) in operands.iter().enumerate() {
 212                     let op = self.eval_operand(operand, None)?;
 213                     // Ignore zero-sized fields.
 214                     if !op.layout.is_zst() {
 215                         let field_index = active_field_index.unwrap_or(i);
 216                         let field_dest = self.place_field(dest, field_index as u64)?;
 217                         self.copy_op(op, field_dest)?;
 218                     }
 219                 }
 220             }
 221
 222             Repeat(ref operand, _) => {
 223                 let op = self.eval_operand(operand, None)?;
 224                 let dest = self.force_allocation(dest)?;
 225                 let length = dest.len(self)?;
 226
 227                 if length > 0 {
 228                     // write the first
 229                     let first = self.mplace_field(dest, 0)?;
 230                     self.copy_op(op, first.into())?;
 231
 232                     if length > 1 {
 233                         // copy the rest
 234                         let (dest, dest_align) = first.to_scalar_ptr_align();
 235                         let rest = dest.ptr_offset(first.layout.size, self)?;
 236                         self.memory.copy_repeatedly(
 237                             dest, dest_align, rest, dest_align, first.layout.size, length - 1, true
 238                         )?;
 239                     }
 240                 }
 241             }
 242
 243             Len(ref place) => {
 244                 // FIXME(CTFE): don't allow computing the length of arrays in const eval
 245                 let src = self.eval_place(place)?;
 246                 let mplace = self.force_allocation(src)?;
 247                 let len = mplace.len(self)?;
 248                 let size = self.pointer_size();
 249                 self.write_scalar(
 250                     Scalar::from_uint(len, size),
 251                     dest,
 252                 )?;
 253             }
 254
 255             Ref(_, _, ref place) => {
 256                 let src = self.eval_place(place)?;
 257                 let val = self.force_allocation(src)?;
 258                 self.write_immediate(val.to_ref(), dest)?;
 259             }
 260
 261             NullaryOp(mir::NullOp::Box, _) => {
 262                 M::box_alloc(self, dest)?;
 263             }
 264
 265             NullaryOp(mir::NullOp::SizeOf, ty) => {
 266                 let ty = self.monomorphize(ty, self.substs());
 267                 let layout = self.layout_of(ty)?;
 268                 assert!(!layout.is_unsized(),
 269                         "SizeOf nullary MIR operator called for unsized type");
 270                 let size = self.pointer_size();
 271                 self.write_scalar(
 272                     Scalar::from_uint(layout.size.bytes(), size),
 273                     dest,
 274                 )?;
 275             }
 276
 277             Cast(kind, ref operand, cast_ty) => {
 278                 debug_assert_eq!(self.monomorphize(cast_ty, self.substs()), dest.layout.ty);
 279                 let src = self.eval_operand(operand, None)?;
 280                 self.cast(src, kind, dest)?;
 281             }
 282
 283             Discriminant(ref place) => {
 284                 let place = self.eval_place(place)?;
 285                 let discr_val = self.read_discriminant(self.place_to_op(place)?)?.0;
 286                 let size = dest.layout.size;
 287                 self.write_scalar(Scalar::from_uint(discr_val, size), dest)?;
 288             }
 289         }
 290
 291         self.dump_place(*dest);
 292
 293         Ok(())
 294     }
 295
 296     fn terminator(&mut self, terminator: &mir::Terminator<'tcx>) -> EvalResult<'tcx> {
 297         debug!("{:?}", terminator.kind);
 298         self.tcx.span = terminator.source_info.span;
 299         self.memory.tcx.span = terminator.source_info.span;
 300
 301         let old_stack = self.cur_frame();
 302         let old_bb = self.frame().block;
 303         self.eval_terminator(terminator)?;
 304         if !self.stack.is_empty() {
 305             // This should change *something*
 306             debug_assert!(self.cur_frame() != old_stack || self.frame().block != old_bb);
 307             debug!("// {:?}", self.frame().block);
 308         }
 309         Ok(())
 310     }
 311 }