use crate::*;
-use helpers::check_arg_count;
-use rustc_middle::ty::{self, TypeAndMut};
use rustc_ast::ast::Mutability;
-use rustc_span::BytePos;
-use rustc_target::abi::Size;
-use std::convert::TryInto as _;
-use crate::rustc_target::abi::LayoutOf as _;
+use rustc_middle::ty::layout::LayoutOf as _;
+use rustc_middle::ty::{self, Instance};
+use rustc_span::{BytePos, Loc, Symbol};
+use rustc_target::{abi::Size, spec::abi::Abi};
impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
-
- fn handle_miri_get_backtrace(
+ fn handle_miri_backtrace_size(
&mut self,
- args: &[OpTy<'tcx, Tag>],
- dest: PlaceTy<'tcx, Tag>
+ abi: Abi,
+ link_name: Symbol,
+ args: &[OpTy<'tcx, Provenance>],
+ dest: &PlaceTy<'tcx, Provenance>,
) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- let tcx = this.tcx;
- let &[flags] = check_arg_count(args)?;
+ let [flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
let flags = this.read_scalar(flags)?.to_u64()?;
if flags != 0 {
- throw_unsup_format!("unknown `miri_get_backtrace` flags {}", flags);
+ throw_unsup_format!("unknown `miri_backtrace_size` flags {}", flags);
}
+ let frame_count = this.active_thread_stack().len();
+
+ this.write_scalar(Scalar::from_machine_usize(frame_count.try_into().unwrap(), this), dest)
+ }
+
+ fn handle_miri_get_backtrace(
+ &mut self,
+ abi: Abi,
+ link_name: Symbol,
+ args: &[OpTy<'tcx, Provenance>],
+ dest: &PlaceTy<'tcx, Provenance>,
+ ) -> InterpResult<'tcx> {
+ let this = self.eval_context_mut();
+ let tcx = this.tcx;
+
+ let flags = if let Some(flags_op) = args.get(0) {
+ this.read_scalar(flags_op)?.to_u64()?
+ } else {
+ throw_ub_format!("expected at least 1 argument")
+ };
+
let mut data = Vec::new();
for frame in this.active_thread_stack().iter().rev() {
let mut span = frame.current_span();
// Match the behavior of runtime backtrace spans
// by using a non-macro span in our backtrace. See `FunctionCx::debug_loc`.
- if span.from_expansion() && !tcx.sess.opts.debugging_opts.debug_macros {
+ if span.from_expansion() && !tcx.sess.opts.unstable_opts.debug_macros {
span = rustc_span::hygiene::walk_chain(span, frame.body.span.ctxt())
}
data.push((frame.instance, span.lo()));
}
- let ptrs: Vec<_> = data.into_iter().map(|(instance, pos)| {
- // We represent a frame pointer by using the `span.lo` value
- // as an offset into the function's allocation. This gives us an
- // opaque pointer that we can return to user code, and allows us
- // to reconstruct the needed frame information in `handle_miri_resolve_frame`.
- // Note that we never actually read or write anything from/to this pointer -
- // all of the data is represented by the pointer value itself.
- let mut fn_ptr = this.memory.create_fn_alloc(FnVal::Instance(instance));
- fn_ptr.offset = Size::from_bytes(pos.0);
- Scalar::Ptr(fn_ptr)
- }).collect();
-
- let len = ptrs.len();
-
- let ptr_ty = tcx.mk_ptr(TypeAndMut {
- ty: tcx.types.unit,
- mutbl: Mutability::Mut
- });
-
- let array_ty = tcx.mk_array(ptr_ty, ptrs.len().try_into().unwrap());
-
- // Write pointers into array
- let alloc = this.allocate(this.layout_of(array_ty).unwrap(), MiriMemoryKind::Rust.into());
- for (i, ptr) in ptrs.into_iter().enumerate() {
- let place = this.mplace_index(alloc, i as u64)?;
- this.write_immediate_to_mplace(ptr.into(), place)?;
- }
+ let ptrs: Vec<_> = data
+ .into_iter()
+ .map(|(instance, pos)| {
+ // We represent a frame pointer by using the `span.lo` value
+ // as an offset into the function's allocation. This gives us an
+ // opaque pointer that we can return to user code, and allows us
+ // to reconstruct the needed frame information in `handle_miri_resolve_frame`.
+ // Note that we never actually read or write anything from/to this pointer -
+ // all of the data is represented by the pointer value itself.
+ let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(instance));
+ fn_ptr.wrapping_offset(Size::from_bytes(pos.0), this)
+ })
+ .collect();
+
+ let len: u64 = ptrs.len().try_into().unwrap();
+
+ let ptr_ty = this.machine.layouts.mut_raw_ptr.ty;
+ let array_layout = this.layout_of(tcx.mk_array(ptr_ty, len)).unwrap();
+
+ match flags {
+ // storage for pointers is allocated by miri
+ // deallocating the slice is undefined behavior with a custom global allocator
+ 0 => {
+ let [_flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
+
+ let alloc = this.allocate(array_layout, MiriMemoryKind::Rust.into())?;
+
+ // Write pointers into array
+ for (i, ptr) in ptrs.into_iter().enumerate() {
+ let place = this.mplace_index(&alloc, i as u64)?;
+
+ this.write_pointer(ptr, &place.into())?;
+ }
+
+ this.write_immediate(
+ Immediate::new_slice(Scalar::from_maybe_pointer(alloc.ptr, this), len, this),
+ dest,
+ )?;
+ }
+ // storage for pointers is allocated by the caller
+ 1 => {
+ let [_flags, buf] = this.check_shim(abi, Abi::Rust, link_name, args)?;
+
+ let buf_place = this.deref_operand(buf)?;
+
+ let ptr_layout = this.layout_of(ptr_ty)?;
+
+ for (i, ptr) in ptrs.into_iter().enumerate() {
+ let offset = ptr_layout.size * i.try_into().unwrap();
+
+ let op_place = buf_place.offset(offset, ptr_layout, this)?;
+
+ this.write_pointer(ptr, &op_place.into())?;
+ }
+ }
+ _ => throw_unsup_format!("unknown `miri_get_backtrace` flags {}", flags),
+ };
- this.write_immediate(Immediate::new_slice(alloc.ptr.into(), len.try_into().unwrap(), this), dest)?;
Ok(())
}
- fn handle_miri_resolve_frame(
+ fn resolve_frame_pointer(
&mut self,
- args: &[OpTy<'tcx, Tag>],
- dest: PlaceTy<'tcx, Tag>
- ) -> InterpResult<'tcx> {
+ ptr: &OpTy<'tcx, Provenance>,
+ ) -> InterpResult<'tcx, (Instance<'tcx>, Loc, String, String)> {
let this = self.eval_context_mut();
- let tcx = this.tcx;
- let &[ptr, flags] = check_arg_count(args)?;
-
- let flags = this.read_scalar(flags)?.to_u64()?;
- if flags != 0 {
- throw_unsup_format!("unknown `miri_resolve_frame` flags {}", flags);
- }
- let ptr = match this.read_scalar(ptr)?.check_init()? {
- Scalar::Ptr(ptr) => ptr,
- Scalar::Raw { .. } => throw_ub_format!("expected a pointer in `rust_miri_resolve_frame`, found {:?}", ptr)
- };
+ let ptr = this.read_pointer(ptr)?;
+ // Take apart the pointer, we need its pieces. The offset encodes the span.
+ let (alloc_id, offset, _prov) = this.ptr_get_alloc_id(ptr)?;
- let fn_instance = if let Some(GlobalAlloc::Function(instance)) = this.tcx.get_global_alloc(ptr.alloc_id) {
+ // This has to be an actual global fn ptr, not a dlsym function.
+ let fn_instance = if let Some(GlobalAlloc::Function(instance)) =
+ this.tcx.try_get_global_alloc(alloc_id)
+ {
instance
} else {
- throw_ub_format!("expected function pointer, found {:?}", ptr);
+ throw_ub_format!("expected static function pointer, found {:?}", ptr);
};
+ let lo =
+ this.tcx.sess.source_map().lookup_char_pos(BytePos(offset.bytes().try_into().unwrap()));
+
+ let name = fn_instance.to_string();
+ let filename = lo.file.name.prefer_remapped().to_string();
+
+ Ok((fn_instance, lo, name, filename))
+ }
+
+ fn handle_miri_resolve_frame(
+ &mut self,
+ abi: Abi,
+ link_name: Symbol,
+ args: &[OpTy<'tcx, Provenance>],
+ dest: &PlaceTy<'tcx, Provenance>,
+ ) -> InterpResult<'tcx> {
+ let this = self.eval_context_mut();
+ let [ptr, flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
+
+ let flags = this.read_scalar(flags)?.to_u64()?;
+
+ let (fn_instance, lo, name, filename) = this.resolve_frame_pointer(ptr)?;
+
// Reconstruct the original function pointer,
// which we pass to user code.
- let mut fn_ptr = ptr;
- fn_ptr.offset = Size::from_bytes(0);
- let fn_ptr = Scalar::Ptr(fn_ptr);
+ let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(fn_instance));
- let num_fields = dest.layout.layout.fields.count();
+ let num_fields = dest.layout.fields.count();
if !(4..=5).contains(&num_fields) {
// Always mention 5 fields, since the 4-field struct
// is deprecated and slated for removal.
- throw_ub_format!("bad declaration of miri_resolve_frame - should return a struct with 5 fields");
+ throw_ub_format!(
+ "bad declaration of miri_resolve_frame - should return a struct with 5 fields"
+ );
}
- let pos = BytePos(ptr.offset.bytes().try_into().unwrap());
- let name = fn_instance.to_string();
-
- let lo = tcx.sess.source_map().lookup_char_pos(pos);
-
- let filename = lo.file.name.to_string();
- let lineno: u32 = lo.line as u32;
+ // `u32` is not enough to fit line/colno, which can be `usize`. It seems unlikely that a
+ // file would have more than 2^32 lines or columns, but whatever, just default to 0.
+ let lineno: u32 = u32::try_from(lo.line).unwrap_or(0);
// `lo.col` is 0-based - add 1 to make it 1-based for the caller.
- let colno: u32 = lo.col.0 as u32 + 1;
-
- let name_alloc = this.allocate_str(&name, MiriMemoryKind::Rust.into());
- let filename_alloc = this.allocate_str(&filename, MiriMemoryKind::Rust.into());
- let lineno_alloc = Scalar::from_u32(lineno);
- let colno_alloc = Scalar::from_u32(colno);
+ let colno: u32 = u32::try_from(lo.col.0 + 1).unwrap_or(0);
let dest = this.force_allocation(dest)?;
if let ty::Adt(adt, _) = dest.layout.ty.kind() {
- if !adt.repr.c() {
- throw_ub_format!("miri_resolve_frame must be declared with a `#[repr(C)]` return type");
+ if !adt.repr().c() {
+ throw_ub_format!(
+ "miri_resolve_frame must be declared with a `#[repr(C)]` return type"
+ );
}
}
- this.write_immediate(name_alloc.to_ref(), this.mplace_field(dest, 0)?.into())?;
- this.write_immediate(filename_alloc.to_ref(), this.mplace_field(dest, 1)?.into())?;
- this.write_scalar(lineno_alloc, this.mplace_field(dest, 2)?.into())?;
- this.write_scalar(colno_alloc, this.mplace_field(dest, 3)?.into())?;
+ match flags {
+ 0 => {
+ // These are "mutable" allocations as we consider them to be owned by the callee.
+ let name_alloc =
+ this.allocate_str(&name, MiriMemoryKind::Rust.into(), Mutability::Mut);
+ let filename_alloc =
+ this.allocate_str(&filename, MiriMemoryKind::Rust.into(), Mutability::Mut);
+
+ this.write_immediate(
+ name_alloc.to_ref(this),
+ &this.mplace_field(&dest, 0)?.into(),
+ )?;
+ this.write_immediate(
+ filename_alloc.to_ref(this),
+ &this.mplace_field(&dest, 1)?.into(),
+ )?;
+ }
+ 1 => {
+ this.write_scalar(
+ Scalar::from_machine_usize(name.len().try_into().unwrap(), this),
+ &this.mplace_field(&dest, 0)?.into(),
+ )?;
+ this.write_scalar(
+ Scalar::from_machine_usize(filename.len().try_into().unwrap(), this),
+ &this.mplace_field(&dest, 1)?.into(),
+ )?;
+ }
+ _ => throw_unsup_format!("unknown `miri_resolve_frame` flags {}", flags),
+ }
+
+ this.write_scalar(Scalar::from_u32(lineno), &this.mplace_field(&dest, 2)?.into())?;
+ this.write_scalar(Scalar::from_u32(colno), &this.mplace_field(&dest, 3)?.into())?;
// Support a 4-field struct for now - this is deprecated
// and slated for removal.
if num_fields == 5 {
- this.write_scalar(fn_ptr, this.mplace_field(dest, 4)?.into())?;
+ this.write_pointer(fn_ptr, &this.mplace_field(&dest, 4)?.into())?;
+ }
+
+ Ok(())
+ }
+
+ fn handle_miri_resolve_frame_names(
+ &mut self,
+ abi: Abi,
+ link_name: Symbol,
+ args: &[OpTy<'tcx, Provenance>],
+ ) -> InterpResult<'tcx> {
+ let this = self.eval_context_mut();
+
+ let [ptr, flags, name_ptr, filename_ptr] =
+ this.check_shim(abi, Abi::Rust, link_name, args)?;
+
+ let flags = this.read_scalar(flags)?.to_u64()?;
+ if flags != 0 {
+ throw_unsup_format!("unknown `miri_resolve_frame_names` flags {}", flags);
}
+ let (_, _, name, filename) = this.resolve_frame_pointer(ptr)?;
+
+ this.write_bytes_ptr(this.read_pointer(name_ptr)?, name.bytes())?;
+ this.write_bytes_ptr(this.read_pointer(filename_ptr)?, filename.bytes())?;
+
Ok(())
}
}
projects / rust.git / blobdiff