1 use rustc::hir::def_id::DefId;
2 use rustc::mir::repr as mir;
3 use rustc::traits::{self, ProjectionMode};
4 use rustc::ty::fold::TypeFoldable;
5 use rustc::ty::layout::Layout;
6 use rustc::ty::subst::{self, Substs};
7 use rustc::ty::{self, Ty, TyCtxt, BareFnTy};
10 use syntax::{ast, attr};
11 use syntax::codemap::{DUMMY_SP, Span};
13 use super::{EvalContext, IntegerExt};
14 use error::{EvalError, EvalResult};
15 use memory::{Pointer, FunctionDefinition};
17 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
18 pub(super) fn eval_terminator(
20 terminator: &mir::Terminator<'tcx>,
21 ) -> EvalResult<'tcx, ()> {
22 use rustc::mir::repr::TerminatorKind::*;
23 match terminator.kind {
24 Return => self.pop_stack_frame(),
27 self.frame_mut().block = target;
30 If { ref cond, targets: (then_target, else_target) } => {
31 let cond_ptr = self.eval_operand(cond)?;
32 let cond_val = self.memory.read_bool(cond_ptr)?;
33 self.frame_mut().block = if cond_val { then_target } else { else_target };
36 SwitchInt { ref discr, ref values, ref targets, .. } => {
37 let discr_ptr = self.eval_lvalue(discr)?.to_ptr();
38 let discr_ty = self.lvalue_ty(discr);
40 .type_layout(discr_ty)
41 .size(&self.tcx.data_layout)
43 let discr_val = self.memory.read_uint(discr_ptr, discr_size)?;
44 if let ty::TyChar = discr_ty.sty {
45 if ::std::char::from_u32(discr_val as u32).is_none() {
46 return Err(EvalError::InvalidChar(discr_val as u32));
50 // Branch to the `otherwise` case by default, if no match is found.
51 let mut target_block = targets[targets.len() - 1];
53 for (index, val_const) in values.iter().enumerate() {
54 let ptr = self.const_to_ptr(val_const)?;
55 let val = self.memory.read_uint(ptr, discr_size)?;
57 target_block = targets[index];
62 self.frame_mut().block = target_block;
65 Switch { ref discr, ref targets, adt_def } => {
66 let adt_ptr = self.eval_lvalue(discr)?.to_ptr();
67 let adt_ty = self.lvalue_ty(discr);
68 let discr_val = self.read_discriminant_value(adt_ptr, adt_ty)?;
69 let matching = adt_def.variants.iter()
70 .position(|v| discr_val == v.disr_val.to_u64_unchecked());
74 self.frame_mut().block = targets[i];
76 None => return Err(EvalError::InvalidDiscriminant),
80 Call { ref func, ref args, ref destination, .. } => {
81 let mut return_ptr = None;
82 if let Some((ref lv, target)) = *destination {
83 self.frame_mut().block = target;
84 return_ptr = Some(self.eval_lvalue(lv)?.to_ptr());
87 let func_ty = self.operand_ty(func);
89 ty::TyFnPtr(bare_fn_ty) => {
90 let ptr = self.eval_operand(func)?;
91 let fn_ptr = self.memory.read_ptr(ptr)?;
92 let FunctionDefinition { def_id, substs, fn_ty } = self.memory.get_fn(fn_ptr.alloc_id)?;
93 if fn_ty != bare_fn_ty {
94 return Err(EvalError::FunctionPointerTyMismatch(fn_ty, bare_fn_ty));
96 self.eval_fn_call(def_id, substs, bare_fn_ty, return_ptr, args,
97 terminator.source_info.span)?
99 ty::TyFnDef(def_id, substs, fn_ty) => {
100 self.eval_fn_call(def_id, substs, fn_ty, return_ptr, args,
101 terminator.source_info.span)?
104 _ => return Err(EvalError::Unimplemented(format!("can't handle callee of type {:?}", func_ty))),
108 Drop { ref location, target, .. } => {
109 let ptr = self.eval_lvalue(location)?.to_ptr();
110 let ty = self.lvalue_ty(location);
112 self.frame_mut().block = target;
115 Assert { ref cond, expected, ref msg, target, .. } => {
116 let cond_ptr = self.eval_operand(cond)?;
117 if expected == self.memory.read_bool(cond_ptr)? {
118 self.frame_mut().block = target;
121 mir::AssertMessage::BoundsCheck { ref len, ref index } => {
122 let len = self.eval_operand(len).expect("can't eval len");
123 let len = self.memory.read_usize(len).expect("can't read len");
124 let index = self.eval_operand(index).expect("can't eval index");
125 let index = self.memory.read_usize(index).expect("can't read index");
126 Err(EvalError::ArrayIndexOutOfBounds(terminator.source_info.span, len, index))
128 mir::AssertMessage::Math(ref err) => Err(EvalError::Math(terminator.source_info.span, err.clone())),
133 DropAndReplace { .. } => unimplemented!(),
134 Resume => unimplemented!(),
135 Unreachable => unimplemented!(),
144 substs: &'tcx Substs<'tcx>,
145 fn_ty: &'tcx BareFnTy,
146 return_ptr: Option<Pointer>,
147 args: &[mir::Operand<'tcx>],
149 ) -> EvalResult<'tcx, ()> {
150 use syntax::abi::Abi;
152 Abi::RustIntrinsic => {
153 let name = self.tcx.item_name(def_id).as_str();
154 match fn_ty.sig.0.output {
155 ty::FnConverging(ty) => {
156 let layout = self.type_layout(ty);
157 let ret = return_ptr.unwrap();
158 self.call_intrinsic(&name, substs, args, ret, layout)
160 ty::FnDiverging => unimplemented!(),
165 match fn_ty.sig.0.output {
166 ty::FnConverging(ty) => {
167 let size = self.type_size(ty);
168 self.call_c_abi(def_id, args, return_ptr.unwrap(), size)
170 ty::FnDiverging => unimplemented!(),
174 Abi::Rust | Abi::RustCall => {
175 // TODO(solson): Adjust the first argument when calling a Fn or
176 // FnMut closure via FnOnce::call_once.
178 // Only trait methods can have a Self parameter.
179 let (resolved_def_id, resolved_substs) = if substs.self_ty().is_some() {
180 self.trait_method(def_id, substs)
185 let mut arg_srcs = Vec::new();
187 let src = self.eval_operand(arg)?;
188 let src_ty = self.operand_ty(arg);
189 arg_srcs.push((src, src_ty));
192 if fn_ty.abi == Abi::RustCall && !args.is_empty() {
194 let last_arg = args.last().unwrap();
195 let last = self.eval_operand(last_arg)?;
196 let last_ty = self.operand_ty(last_arg);
197 let last_layout = self.type_layout(last_ty);
198 match (&last_ty.sty, last_layout) {
199 (&ty::TyTuple(fields),
200 &Layout::Univariant { ref variant, .. }) => {
201 let offsets = iter::once(0)
202 .chain(variant.offset_after_field.iter()
203 .map(|s| s.bytes()));
204 for (offset, ty) in offsets.zip(fields) {
205 let src = last.offset(offset as isize);
206 arg_srcs.push((src, ty));
209 ty => panic!("expected tuple as last argument in function with 'rust-call' ABI, got {:?}", ty),
213 let mir = self.load_mir(resolved_def_id);
214 self.push_stack_frame(def_id, span, mir, resolved_substs, return_ptr)?;
216 for (i, (src, src_ty)) in arg_srcs.into_iter().enumerate() {
217 let dest = self.frame().locals[i];
218 self.move_(src, dest, src_ty)?;
224 abi => Err(EvalError::Unimplemented(format!("can't handle function with {:?} ABI", abi))),
228 fn read_discriminant_value(&self, adt_ptr: Pointer, adt_ty: Ty<'tcx>) -> EvalResult<'tcx, u64> {
229 use rustc::ty::layout::Layout::*;
230 let adt_layout = self.type_layout(adt_ty);
232 let discr_val = match *adt_layout {
233 General { discr, .. } | CEnum { discr, .. } => {
234 let discr_size = discr.size().bytes();
235 self.memory.read_uint(adt_ptr, discr_size as usize)?
238 RawNullablePointer { nndiscr, .. } => {
239 self.read_nonnull_discriminant_value(adt_ptr, nndiscr)?
242 StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => {
243 let offset = self.nonnull_offset(adt_ty, nndiscr, discrfield)?;
244 let nonnull = adt_ptr.offset(offset.bytes() as isize);
245 self.read_nonnull_discriminant_value(nonnull, nndiscr)?
248 // The discriminant_value intrinsic returns 0 for non-sum types.
249 Array { .. } | FatPointer { .. } | Scalar { .. } | Univariant { .. } |
256 fn read_nonnull_discriminant_value(&self, ptr: Pointer, nndiscr: u64) -> EvalResult<'tcx, u64> {
257 let not_null = match self.memory.read_usize(ptr) {
259 Ok(_) | Err(EvalError::ReadPointerAsBytes) => true,
260 Err(e) => return Err(e),
262 assert!(nndiscr == 0 || nndiscr == 1);
263 Ok(if not_null { nndiscr } else { 1 - nndiscr })
269 substs: &'tcx Substs<'tcx>,
270 args: &[mir::Operand<'tcx>],
272 dest_layout: &'tcx Layout,
273 ) -> EvalResult<'tcx, ()> {
274 let args_res: EvalResult<Vec<Pointer>> = args.iter()
275 .map(|arg| self.eval_operand(arg))
277 let args_ptrs = args_res?;
279 let pointer_size = self.memory.pointer_size();
282 "add_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Add, &args[0], &args[1], dest, dest_layout)?,
283 "sub_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Sub, &args[0], &args[1], dest, dest_layout)?,
284 "mul_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Mul, &args[0], &args[1], dest, dest_layout)?,
286 // FIXME: turn into an assertion to catch wrong `assume` that would cause UB in llvm
289 "copy_nonoverlapping" => {
290 let elem_ty = *substs.types.get(subst::FnSpace, 0);
291 let elem_size = self.type_size(elem_ty);
292 let elem_align = self.type_align(elem_ty);
293 let src = self.memory.read_ptr(args_ptrs[0])?;
294 let dest = self.memory.read_ptr(args_ptrs[1])?;
295 let count = self.memory.read_isize(args_ptrs[2])?;
296 self.memory.copy(src, dest, count as usize * elem_size, elem_align)?;
299 "discriminant_value" => {
300 let ty = *substs.types.get(subst::FnSpace, 0);
301 let adt_ptr = self.memory.read_ptr(args_ptrs[0])?;
302 let discr_val = self.read_discriminant_value(adt_ptr, ty)?;
303 self.memory.write_uint(dest, discr_val, 8)?;
308 "init" => self.memory.write_repeat(dest, 0, dest_layout.size(&self.tcx.data_layout).bytes() as usize)?,
311 let elem_ty = *substs.types.get(subst::FnSpace, 0);
312 let elem_align = self.type_align(elem_ty);
313 self.memory.write_uint(dest, elem_align as u64, pointer_size)?;
317 let ty = *substs.types.get(subst::FnSpace, 0);
318 let ptr = self.memory.read_ptr(args_ptrs[0])?;
319 self.move_(args_ptrs[1], ptr, ty)?;
323 let pointee_ty = *substs.types.get(subst::FnSpace, 0);
324 let pointee_size = self.type_size(pointee_ty) as isize;
325 let ptr_arg = args_ptrs[0];
326 let offset = self.memory.read_isize(args_ptrs[1])?;
328 match self.memory.read_ptr(ptr_arg) {
330 let result_ptr = ptr.offset(offset as isize * pointee_size);
331 self.memory.write_ptr(dest, result_ptr)?;
333 Err(EvalError::ReadBytesAsPointer) => {
334 let addr = self.memory.read_isize(ptr_arg)?;
335 let result_addr = addr + offset * pointee_size as i64;
336 self.memory.write_isize(dest, result_addr)?;
338 Err(e) => return Err(e),
342 "overflowing_sub" => {
343 self.intrinsic_overflowing(mir::BinOp::Sub, &args[0], &args[1], dest)?;
345 "overflowing_mul" => {
346 self.intrinsic_overflowing(mir::BinOp::Mul, &args[0], &args[1], dest)?;
348 "overflowing_add" => {
349 self.intrinsic_overflowing(mir::BinOp::Add, &args[0], &args[1], dest)?;
353 let ty = *substs.types.get(subst::FnSpace, 0);
354 let size = self.type_size(ty) as u64;
355 self.memory.write_uint(dest, size, pointer_size)?;
359 let ty = *substs.types.get(subst::FnSpace, 0);
360 if self.type_is_sized(ty) {
361 let size = self.type_size(ty) as u64;
362 self.memory.write_uint(dest, size, pointer_size)?;
365 ty::TySlice(_) | ty::TyStr => {
366 let elem_ty = ty.sequence_element_type(self.tcx);
367 let elem_size = self.type_size(elem_ty) as u64;
368 let ptr_size = self.memory.pointer_size() as isize;
369 let n = self.memory.read_usize(args_ptrs[0].offset(ptr_size))?;
370 self.memory.write_uint(dest, n * elem_size, pointer_size)?;
373 _ => return Err(EvalError::Unimplemented(format!("unimplemented: size_of_val::<{:?}>", ty))),
379 let ty = *substs.types.get(subst::FnSpace, 0);
380 self.move_(args_ptrs[0], dest, ty)?;
382 "uninit" => self.memory.mark_definedness(dest, dest_layout.size(&self.tcx.data_layout).bytes() as usize, false)?,
384 name => return Err(EvalError::Unimplemented(format!("unimplemented intrinsic: {}", name))),
387 // Since we pushed no stack frame, the main loop will act
388 // as if the call just completed and it's returning to the
396 args: &[mir::Operand<'tcx>],
399 ) -> EvalResult<'tcx, ()> {
400 let name = self.tcx.item_name(def_id);
401 let attrs = self.tcx.get_attrs(def_id);
402 let link_name = match attr::first_attr_value_str_by_name(&attrs, "link_name") {
403 Some(ln) => ln.clone(),
404 None => name.as_str(),
407 let args_res: EvalResult<Vec<Pointer>> = args.iter()
408 .map(|arg| self.eval_operand(arg))
410 let args = args_res?;
412 if link_name.starts_with("pthread_") {
413 warn!("ignoring C ABI call: {}", link_name);
417 match &link_name[..] {
418 "__rust_allocate" => {
419 let size = self.memory.read_usize(args[0])?;
420 let align = self.memory.read_usize(args[1])?;
421 let ptr = self.memory.allocate(size as usize, align as usize)?;
422 self.memory.write_ptr(dest, ptr)?;
425 "__rust_reallocate" => {
426 let ptr = self.memory.read_ptr(args[0])?;
427 let size = self.memory.read_usize(args[2])?;
428 let align = self.memory.read_usize(args[3])?;
429 let new_ptr = self.memory.reallocate(ptr, size as usize, align as usize)?;
430 self.memory.write_ptr(dest, new_ptr)?;
434 let left = self.memory.read_ptr(args[0])?;
435 let right = self.memory.read_ptr(args[1])?;
436 let n = self.memory.read_usize(args[2])? as usize;
439 let left_bytes = self.memory.read_bytes(left, n)?;
440 let right_bytes = self.memory.read_bytes(right, n)?;
442 use std::cmp::Ordering::*;
443 match left_bytes.cmp(right_bytes) {
450 self.memory.write_int(dest, result, dest_size)?;
454 return Err(EvalError::Unimplemented(format!("can't call C ABI function: {}", link_name)));
458 // Since we pushed no stack frame, the main loop will act
459 // as if the call just completed and it's returning to the
464 fn fulfill_obligation(&self, trait_ref: ty::PolyTraitRef<'tcx>) -> traits::Vtable<'tcx, ()> {
465 // Do the initial selection for the obligation. This yields the shallow result we are
466 // looking for -- that is, what specific impl.
467 self.tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| {
468 let mut selcx = traits::SelectionContext::new(&infcx);
470 let obligation = traits::Obligation::new(
471 traits::ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID),
472 trait_ref.to_poly_trait_predicate(),
474 let selection = selcx.select(&obligation).unwrap().unwrap();
476 // Currently, we use a fulfillment context to completely resolve all nested obligations.
477 // This is because they can inform the inference of the impl's type parameters.
478 let mut fulfill_cx = traits::FulfillmentContext::new();
479 let vtable = selection.map(|predicate| {
480 fulfill_cx.register_predicate_obligation(&infcx, predicate);
482 infcx.drain_fulfillment_cx_or_panic(DUMMY_SP, &mut fulfill_cx, &vtable)
486 /// Trait method, which has to be resolved to an impl method.
490 substs: &'tcx Substs<'tcx>
491 ) -> (DefId, &'tcx Substs<'tcx>) {
492 let method_item = self.tcx.impl_or_trait_item(def_id);
493 let trait_id = method_item.container().id();
494 let trait_ref = ty::Binder(substs.to_trait_ref(self.tcx, trait_id));
495 match self.fulfill_obligation(trait_ref) {
496 traits::VtableImpl(vtable_impl) => {
497 let impl_did = vtable_impl.impl_def_id;
498 let mname = self.tcx.item_name(def_id);
499 // Create a concatenated set of substitutions which includes those from the impl
500 // and those from the method:
501 let impl_substs = vtable_impl.substs.with_method_from(substs);
502 let substs = self.tcx.mk_substs(impl_substs);
503 let mth = get_impl_method(self.tcx, impl_did, substs, mname);
505 (mth.method.def_id, mth.substs)
508 traits::VtableClosure(vtable_closure) =>
509 (vtable_closure.closure_def_id, vtable_closure.substs.func_substs),
511 traits::VtableFnPointer(_fn_ty) => {
512 let _trait_closure_kind = self.tcx.lang_items.fn_trait_kind(trait_id).unwrap();
514 // let llfn = trans_fn_pointer_shim(ccx, trait_closure_kind, fn_ty);
516 // let method_ty = def_ty(tcx, def_id, substs);
517 // let fn_ptr_ty = match method_ty.sty {
518 // ty::TyFnDef(_, _, fty) => tcx.mk_ty(ty::TyFnPtr(fty)),
519 // _ => unreachable!("expected fn item type, found {}",
522 // Callee::ptr(immediate_rvalue(llfn, fn_ptr_ty))
525 traits::VtableObject(ref _data) => {
528 // data: Virtual(traits::get_vtable_index_of_object_method(
529 // tcx, data, def_id)),
530 // ty: def_ty(tcx, def_id, substs)
533 vtable => unreachable!("resolved vtable bad vtable {:?} in trans", vtable),
537 pub(super) fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool {
538 self.tcx.type_needs_drop_given_env(ty, &self.tcx.empty_parameter_environment())
541 fn drop(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, ()> {
542 if !self.type_needs_drop(ty) {
543 debug!("no need to drop {:?}", ty);
546 trace!("-need to drop {:?}", ty);
548 // TODO(solson): Call user-defined Drop::drop impls.
551 ty::TyBox(_contents_ty) => {
552 let contents_ptr = self.memory.read_ptr(ptr)?;
553 // self.drop(contents_ptr, contents_ty)?;
554 trace!("-deallocating box");
555 self.memory.deallocate(contents_ptr)?;
558 // TODO(solson): Implement drop for other relevant types (e.g. aggregates).
567 struct ImplMethod<'tcx> {
568 method: Rc<ty::Method<'tcx>>,
569 substs: &'tcx Substs<'tcx>,
573 /// Locates the applicable definition of a method, given its name.
574 fn get_impl_method<'a, 'tcx>(
575 tcx: TyCtxt<'a, 'tcx, 'tcx>,
577 substs: &'tcx Substs<'tcx>,
579 ) -> ImplMethod<'tcx> {
580 assert!(!substs.types.needs_infer());
582 let trait_def_id = tcx.trait_id_of_impl(impl_def_id).unwrap();
583 let trait_def = tcx.lookup_trait_def(trait_def_id);
585 match trait_def.ancestors(impl_def_id).fn_defs(tcx, name).next() {
587 let substs = tcx.normalizing_infer_ctxt(ProjectionMode::Any).enter(|infcx| {
588 let substs = traits::translate_substs(&infcx, impl_def_id,
589 substs, node_item.node);
590 tcx.lift(&substs).unwrap_or_else(|| {
591 bug!("trans::meth::get_impl_method: translate_substs \
592 returned {:?} which contains inference types/regions",
597 method: node_item.item,
599 is_provided: node_item.node.is_from_trait(),
603 bug!("method {:?} not found in {:?}", name, impl_def_id)