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.
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.
11 //! This module contains the `EvalContext` methods for executing a single step of the interpreter.
13 //! The main entry point is the `step` method.
16 use rustc::ty::layout::LayoutOf;
17 use rustc::mir::interpret::{EvalResult, Scalar, PointerArithmetic};
19 use super::{EvalContext, Machine};
21 /// Classify whether an operator is "left-homogeneous", i.e. the LHS has the
22 /// same type as the result.
24 fn binop_left_homogeneous(op: mir::BinOp) -> bool {
25 use rustc::mir::BinOp::*;
27 Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr |
30 Eq | Ne | Lt | Le | Gt | Ge =>
34 /// Classify whether an operator is "right-homogeneous", i.e. the RHS has the
35 /// same type as the LHS.
37 fn binop_right_homogeneous(op: mir::BinOp) -> bool {
38 use rustc::mir::BinOp::*;
40 Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr |
41 Eq | Ne | Lt | Le | Gt | Ge =>
48 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
49 pub fn run(&mut self) -> EvalResult<'tcx> {
54 /// Returns true as long as there are more things to do.
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() {
62 let block = self.frame().block;
63 let stmt_id = self.frame().stmt;
65 let basic_block = &mir.basic_blocks()[block];
67 let old_frames = self.cur_frame();
69 if let Some(stmt) = basic_block.statements.get(stmt_id) {
70 assert_eq!(old_frames, self.cur_frame());
71 self.statement(stmt)?;
75 M::before_terminator(self)?;
77 let terminator = basic_block.terminator();
78 assert_eq!(old_frames, self.cur_frame());
79 self.terminator(terminator)?;
83 fn statement(&mut self, stmt: &mir::Statement<'tcx>) -> EvalResult<'tcx> {
86 use rustc::mir::StatementKind::*;
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;
95 Assign(ref place, ref rvalue) => self.eval_rvalue_into_place(rvalue, place)?,
101 let dest = self.eval_place(place)?;
102 self.write_discriminant_index(variant_index, dest)?;
105 // Mark locals as alive
106 StorageLive(local) => {
107 let old_val = self.storage_live(local)?;
108 self.deallocate_local(old_val)?;
111 // Mark locals as dead
112 StorageDead(local) => {
113 let old_val = self.storage_dead(local);
114 self.deallocate_local(old_val)?;
117 // No dynamic semantics attached to `FakeRead`; MIR
118 // interpreter is solely intended for borrowck'ed code.
122 Retag { fn_entry, two_phase, ref place } => {
123 let dest = self.eval_place(place)?;
124 M::retag(self, fn_entry, two_phase, dest)?;
126 EscapeToRaw(ref op) => {
127 let op = self.eval_operand(op, None)?;
128 M::escape_to_raw(self, op)?;
131 // Statements we do not track.
132 AscribeUserType(..) => {}
134 // Defined to do nothing. These are added by optimization passes, to avoid changing the
135 // size of MIR constantly.
138 InlineAsm { .. } => return err!(InlineAsm),
141 self.stack[frame_idx].stmt += 1;
145 /// Evaluate an assignment statement.
147 /// There is no separate `eval_rvalue` function. Instead, the code for handling each rvalue
148 /// type writes its results directly into the memory specified by the place.
149 fn eval_rvalue_into_place(
151 rvalue: &mir::Rvalue<'tcx>,
152 place: &mir::Place<'tcx>,
153 ) -> EvalResult<'tcx> {
154 let dest = self.eval_place(place)?;
156 use rustc::mir::Rvalue::*;
158 Use(ref operand) => {
159 // Avoid recomputing the layout
160 let op = self.eval_operand(operand, Some(dest.layout))?;
161 self.copy_op(op, dest)?;
164 BinaryOp(bin_op, ref left, ref right) => {
165 let layout = if binop_left_homogeneous(bin_op) { Some(dest.layout) } else { None };
166 let left = self.read_immediate(self.eval_operand(left, layout)?)?;
167 let layout = if binop_right_homogeneous(bin_op) { Some(left.layout) } else { None };
168 let right = self.read_immediate(self.eval_operand(right, layout)?)?;
169 self.binop_ignore_overflow(
177 CheckedBinaryOp(bin_op, ref left, ref right) => {
178 // Due to the extra boolean in the result, we can never reuse the `dest.layout`.
179 let left = self.read_immediate(self.eval_operand(left, None)?)?;
180 let layout = if binop_right_homogeneous(bin_op) { Some(left.layout) } else { None };
181 let right = self.read_immediate(self.eval_operand(right, layout)?)?;
182 self.binop_with_overflow(
190 UnaryOp(un_op, ref operand) => {
191 // The operand always has the same type as the result.
192 let val = self.read_immediate(self.eval_operand(operand, Some(dest.layout))?)?;
193 let val = self.unary_op(un_op, val.to_scalar()?, dest.layout)?;
194 self.write_scalar(val, dest)?;
197 Aggregate(ref kind, ref operands) => {
198 let (dest, active_field_index) = match **kind {
199 mir::AggregateKind::Adt(adt_def, variant_index, _, _, active_field_index) => {
200 self.write_discriminant_index(variant_index, dest)?;
201 if adt_def.is_enum() {
202 (self.place_downcast(dest, variant_index)?, active_field_index)
204 (dest, active_field_index)
210 for (i, operand) in operands.iter().enumerate() {
211 let op = self.eval_operand(operand, None)?;
212 // Ignore zero-sized fields.
213 if !op.layout.is_zst() {
214 let field_index = active_field_index.unwrap_or(i);
215 let field_dest = self.place_field(dest, field_index as u64)?;
216 self.copy_op(op, field_dest)?;
221 Repeat(ref operand, _) => {
222 let op = self.eval_operand(operand, None)?;
223 let dest = self.force_allocation(dest)?;
224 let length = dest.len(self)?;
228 let first = self.mplace_field(dest, 0)?;
229 self.copy_op(op, first.into())?;
233 let (dest, dest_align) = first.to_scalar_ptr_align();
234 let rest = dest.ptr_offset(first.layout.size, self)?;
235 self.memory.copy_repeatedly(
236 dest, dest_align, rest, dest_align, first.layout.size, length - 1, true
243 // FIXME(CTFE): don't allow computing the length of arrays in const eval
244 let src = self.eval_place(place)?;
245 let mplace = self.force_allocation(src)?;
246 let len = mplace.len(self)?;
247 let size = self.pointer_size();
249 Scalar::from_uint(len, size),
254 Ref(_, _, ref place) => {
255 let src = self.eval_place(place)?;
256 let val = self.force_allocation(src)?;
257 self.write_immediate(val.to_ref(), dest)?;
260 NullaryOp(mir::NullOp::Box, _) => {
261 M::box_alloc(self, dest)?;
264 NullaryOp(mir::NullOp::SizeOf, ty) => {
265 let ty = self.monomorphize(ty, self.substs());
266 let layout = self.layout_of(ty)?;
267 assert!(!layout.is_unsized(),
268 "SizeOf nullary MIR operator called for unsized type");
269 let size = self.pointer_size();
271 Scalar::from_uint(layout.size.bytes(), size),
276 Cast(kind, ref operand, cast_ty) => {
277 debug_assert_eq!(self.monomorphize(cast_ty, self.substs()), dest.layout.ty);
278 let src = self.eval_operand(operand, None)?;
279 self.cast(src, kind, dest)?;
282 Discriminant(ref place) => {
283 let place = self.eval_place(place)?;
284 let discr_val = self.read_discriminant(self.place_to_op(place)?)?.0;
285 let size = dest.layout.size;
286 self.write_scalar(Scalar::from_uint(discr_val, size), dest)?;
290 self.dump_place(*dest);
295 fn terminator(&mut self, terminator: &mir::Terminator<'tcx>) -> EvalResult<'tcx> {
296 debug!("{:?}", terminator.kind);
297 self.tcx.span = terminator.source_info.span;
298 self.memory.tcx.span = terminator.source_info.span;
300 let old_stack = self.cur_frame();
301 let old_bb = self.frame().block;
302 self.eval_terminator(terminator)?;
303 if !self.stack.is_empty() {
304 // This should change *something*
305 debug_assert!(self.cur_frame() != old_stack || self.frame().block != old_bb);
306 debug!("// {:?}", self.frame().block);