From 6b939bbd798c42b9e992da36f9158b711063a731 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 8 Jun 2016 11:11:08 +0200 Subject: [PATCH] rebase leftovers --- src/interpreter/mod.rs | 88 ++++++++++++-------------------------- src/interpreter/stepper.rs | 7 +-- 2 files changed, 31 insertions(+), 64 deletions(-) diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs index 22db69a2aff..c1a91fee797 100644 --- a/src/interpreter/mod.rs +++ b/src/interpreter/mod.rs @@ -194,6 +194,7 @@ fn alloc_ret_ptr(&mut self, ty: ty::FnOutput<'tcx>, substs: &'tcx Substs<'tcx>) ty::FnDiverging => None, } } + // TODO(solson): Try making const_to_primval instead. fn const_to_ptr(&mut self, const_val: &const_val::ConstVal) -> EvalResult { use rustc::middle::const_val::ConstVal::*; @@ -337,6 +338,25 @@ fn load_mir(&self, def_id: DefId) -> CachedMir<'a, 'tcx> { } } } + + fn monomorphize(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> { + let substituted = ty.subst(self.tcx, substs); + self.tcx.normalize_associated_type(&substituted) + } + + fn type_size(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> usize { + self.type_layout(ty, substs).size(&self.tcx.data_layout).bytes() as usize + } + + fn type_layout(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> &'tcx Layout { + // TODO(solson): Is this inefficient? Needs investigation. + let ty = self.monomorphize(ty, substs); + + self.tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| { + // TODO(solson): Report this error properly. + ty.layout(&infcx).unwrap() + }) + } } impl<'a, 'b, 'mir, 'tcx> FnEvalContext<'a, 'b, 'mir, 'tcx> { @@ -1308,49 +1328,6 @@ fn eval_lvalue(&mut self, lvalue: &mir::Lvalue<'tcx>) -> EvalResult { Ok(Lvalue { ptr: ptr, extra: LvalueExtra::None }) } - // TODO(solson): Try making const_to_primval instead. - fn const_to_ptr(&mut self, const_val: &const_val::ConstVal) -> EvalResult { - use rustc::middle::const_val::ConstVal::*; - match *const_val { - Float(_f) => unimplemented!(), - Integral(int) => { - // TODO(solson): Check int constant type. - let ptr = self.memory.allocate(8); - self.memory.write_uint(ptr, int.to_u64_unchecked(), 8)?; - Ok(ptr) - } - Str(ref s) => { - let psize = self.memory.pointer_size; - let static_ptr = self.memory.allocate(s.len()); - let ptr = self.memory.allocate(psize * 2); - self.memory.write_bytes(static_ptr, s.as_bytes())?; - self.memory.write_ptr(ptr, static_ptr)?; - self.memory.write_usize(ptr.offset(psize as isize), s.len() as u64)?; - Ok(ptr) - } - ByteStr(ref bs) => { - let psize = self.memory.pointer_size; - let static_ptr = self.memory.allocate(bs.len()); - let ptr = self.memory.allocate(psize); - self.memory.write_bytes(static_ptr, bs)?; - self.memory.write_ptr(ptr, static_ptr)?; - Ok(ptr) - } - Bool(b) => { - let ptr = self.memory.allocate(1); - self.memory.write_bool(ptr, b)?; - Ok(ptr) - } - Char(_c) => unimplemented!(), - Struct(_node_id) => unimplemented!(), - Tuple(_node_id) => unimplemented!(), - Function(_def_id) => unimplemented!(), - Array(_, _) => unimplemented!(), - Repeat(_, _) => unimplemented!(), - Dummy => unimplemented!(), - } - } - fn lvalue_ty(&self, lvalue: &mir::Lvalue<'tcx>) -> Ty<'tcx> { self.monomorphize(self.mir().lvalue_ty(self.tcx, lvalue).to_ty(self.tcx)) } @@ -1360,12 +1337,7 @@ fn operand_ty(&self, operand: &mir::Operand<'tcx>) -> Ty<'tcx> { } fn monomorphize(&self, ty: Ty<'tcx>) -> Ty<'tcx> { - let substituted = ty.subst(self.tcx, self.substs()); - self.tcx.normalize_associated_type(&substituted) - } - - fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool { - self.tcx.type_needs_drop_given_env(ty, &self.tcx.empty_parameter_environment()) + self.gecx.monomorphize(ty, self.substs()) } fn move_(&mut self, src: Pointer, dest: Pointer, ty: Ty<'tcx>) -> EvalResult<()> { @@ -1377,22 +1349,12 @@ fn move_(&mut self, src: Pointer, dest: Pointer, ty: Ty<'tcx>) -> EvalResult<()> Ok(()) } - fn type_is_sized(&self, ty: Ty<'tcx>) -> bool { - ty.is_sized(self.tcx, &self.tcx.empty_parameter_environment(), DUMMY_SP) - } - fn type_size(&self, ty: Ty<'tcx>) -> usize { - self.type_layout(ty).size(&self.tcx.data_layout).bytes() as usize + self.gecx.type_size(ty, self.substs()) } fn type_layout(&self, ty: Ty<'tcx>) -> &'tcx Layout { - // TODO(solson): Is this inefficient? Needs investigation. - let ty = self.monomorphize(ty); - - self.tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| { - // TODO(solson): Report this error properly. - ty.layout(&infcx).unwrap() - }) + self.gecx.type_layout(ty, self.substs()) } pub fn read_primval(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult { @@ -1450,6 +1412,10 @@ fn frame_mut(&mut self) -> &mut Frame<'mir, 'tcx> { fn mir(&self) -> CachedMir<'mir, 'tcx> { self.frame().mir.clone() } + + fn substs(&self) -> &'tcx Substs<'tcx> { + self.frame().substs + } } fn pointee_type(ptr_ty: ty::Ty) -> Option { diff --git a/src/interpreter/stepper.rs b/src/interpreter/stepper.rs index 8807dbcafab..fffac08fc6f 100644 --- a/src/interpreter/stepper.rs +++ b/src/interpreter/stepper.rs @@ -3,7 +3,8 @@ CachedMir, TerminatorTarget, ConstantId, - GlobalEvalContext + GlobalEvalContext, + Frame, }; use error::EvalResult; use rustc::mir::repr as mir; @@ -41,7 +42,7 @@ fn statement(&mut self) -> EvalResult<()> { let stmt = &block_data.statements[self.fncx.frame().stmt]; let mir::StatementKind::Assign(ref lvalue, ref rvalue) = stmt.kind; let result = self.fncx.eval_assignment(lvalue, rvalue); - self.fncx.maybe_report(stmt.span, result)?; + self.fncx.maybe_report(result)?; self.fncx.frame_mut().stmt += 1; Ok(()) } @@ -54,7 +55,7 @@ fn terminator(&mut self) -> EvalResult<()> { let block_data = mir.basic_block_data(self.fncx.frame().next_block); let terminator = block_data.terminator(); let result = self.fncx.eval_terminator(terminator); - self.fncx.maybe_report(terminator.span, result)? + self.fncx.maybe_report(result)? }; match term { TerminatorTarget::Block => {}, -- 2.44.0