miri/shims/

backtrace.rs

use rustc_abi::{FieldIdx, Size};
use rustc_middle::ty::{self, Instance, Ty};
use rustc_span::{BytePos, Loc, Symbol, hygiene};
use rustc_target::callconv::FnAbi;

use crate::*;

impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
    fn handle_miri_backtrace_size(
        &mut self,
        abi: &FnAbi<'tcx, Ty<'tcx>>,
        link_name: Symbol,
        args: &[OpTy<'tcx>],
        dest: &MPlaceTy<'tcx>,
    ) -> InterpResult<'tcx> {
        let ecx = self.eval_context_mut();
        let [flags] =
            &ecx.check_shim_sig(shim_sig!(extern "Rust" fn(u64) -> usize), (link_name, abi, args))?;

        let flags = ecx.read_scalar(flags)?.to_u64()?;
        if flags != 0 {
            throw_unsup_format!("unknown `miri_backtrace_size` flags {}", flags);
        }

        let frame_count = ecx.active_thread_stack().len();

        ecx.write_scalar(Scalar::from_target_usize(frame_count.to_u64(), ecx), dest)
    }

    fn handle_miri_get_backtrace(
        &mut self,
        abi: &FnAbi<'tcx, Ty<'tcx>>,
        link_name: Symbol,
        args: &[OpTy<'tcx>],
    ) -> InterpResult<'tcx> {
        let ecx = self.eval_context_mut();

        let [flags, buf] = &ecx
            .check_shim_sig(shim_sig!(extern "Rust" fn(u64, **()) -> ()), (link_name, abi, args))?;

        let flags = ecx.read_scalar(flags)?.to_u64()?;
        let buf_place = ecx.deref_pointer(buf)?;

        let mut data = Vec::new();
        for frame in ecx.active_thread_stack().iter().rev() {
            // Match behavior of debuginfo (`FunctionCx::adjusted_span_and_dbg_scope`).
            let span = hygiene::walk_chain_collapsed(frame.current_span(), frame.body().span);
            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 fn_ptr = ecx.fn_ptr(FnVal::Instance(instance));
                fn_ptr.wrapping_offset(Size::from_bytes(pos.0), ecx)
            })
            .collect();

        match flags {
            0 => {
                throw_unsup_format!("miri_get_backtrace: v0 is not supported any more");
            }
            1 =>
                for (i, ptr) in ptrs.into_iter().enumerate() {
                    let op_place = ecx.project_c_array_field(&buf_place, i.to_u64())?;
                    ecx.write_pointer(ptr, &op_place)?;
                },
            _ => throw_unsup_format!("unknown `miri_get_backtrace` flags {}", flags),
        };

        interp_ok(())
    }

    fn resolve_frame_pointer(
        &self,
        ptr: &OpTy<'tcx>,
    ) -> InterpResult<'tcx, (Instance<'tcx>, Loc, String, String)> {
        let ecx = self.eval_context_ref();

        let ptr = ecx.read_pointer(ptr)?;
        // Take apart the pointer, we need its pieces. The offset encodes the span.
        let (alloc_id, offset, _prov) = ecx.ptr_get_alloc_id(ptr, 0)?;

        // This has to be an actual global fn ptr, not a dlsym function.
        let Some(GlobalAlloc::Function { instance, .. }) = ecx.tcx.try_get_global_alloc(alloc_id)
        else {
            throw_ub_format!("expected static function pointer, found {:?}", ptr);
        };

        let lo =
            ecx.tcx.sess.source_map().lookup_char_pos(BytePos(offset.bytes().try_into().unwrap()));

        let name = instance.to_string();
        let filename = lo.file.name.prefer_remapped_unconditionally().to_string();

        interp_ok((instance, lo, name, filename))
    }

    fn handle_miri_resolve_frame(
        &mut self,
        abi: &FnAbi<'tcx, Ty<'tcx>>,
        link_name: Symbol,
        args: &[OpTy<'tcx>],
        dest: &MPlaceTy<'tcx>,
    ) -> InterpResult<'tcx> {
        let ecx = self.eval_context_mut();

        // FIXME: not nice to read the type from std but we don't have a good way to construct the
        // type here and now. ADTs need a DefId.
        let [ptr, flags] = &ecx.check_shim_sig(
            shim_sig!(extern "Rust" fn(*_, u64) -> std::backtrace_rs::backtrace::miri::MiriFrame),
            (link_name, abi, args),
        )?;

        let flags = ecx.read_scalar(flags)?.to_u64()?;

        let (fn_instance, lo, name, filename) = ecx.resolve_frame_pointer(ptr)?;

        // Reconstruct the original function pointer,
        // which we pass to user code.
        let fn_ptr = ecx.fn_ptr(FnVal::Instance(fn_instance));

        // `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 = u32::try_from(lo.col.0.saturating_add(1)).unwrap_or(0);

        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"
                );
            }
        }

        match flags {
            0 => {
                throw_unsup_format!("miri_resolve_frame: v0 is not supported any more");
            }
            1 => {
                ecx.write_scalar(
                    Scalar::from_target_usize(name.len().to_u64(), ecx),
                    &ecx.project_field(dest, FieldIdx::from_u32(0))?,
                )?;
                ecx.write_scalar(
                    Scalar::from_target_usize(filename.len().to_u64(), ecx),
                    &ecx.project_field(dest, FieldIdx::from_u32(1))?,
                )?;
            }
            _ => throw_unsup_format!("unknown `miri_resolve_frame` flags {}", flags),
        }

        ecx.write_scalar(
            Scalar::from_u32(lineno),
            &ecx.project_field(dest, FieldIdx::from_u32(2))?,
        )?;
        ecx.write_scalar(
            Scalar::from_u32(colno),
            &ecx.project_field(dest, FieldIdx::from_u32(3))?,
        )?;
        ecx.write_pointer(fn_ptr, &ecx.project_field(dest, FieldIdx::from_u32(4))?)?;

        interp_ok(())
    }

    fn handle_miri_resolve_frame_names(
        &mut self,
        abi: &FnAbi<'tcx, Ty<'tcx>>,
        link_name: Symbol,
        args: &[OpTy<'tcx>],
    ) -> InterpResult<'tcx> {
        let ecx = self.eval_context_mut();

        let [ptr, flags, name_ptr, filename_ptr] = &ecx.check_shim_sig(
            shim_sig!(extern "Rust" fn(*(), u64, *(), *()) -> ()),
            (link_name, abi, args),
        )?;

        let flags = ecx.read_scalar(flags)?.to_u64()?;
        if flags != 0 {
            throw_unsup_format!("unknown `miri_resolve_frame_names` flags {}", flags);
        }

        let (_, _, name, filename) = ecx.resolve_frame_pointer(ptr)?;

        ecx.write_bytes_ptr(ecx.read_pointer(name_ptr)?, name.bytes())?;
        ecx.write_bytes_ptr(ecx.read_pointer(filename_ptr)?, filename.bytes())?;

        interp_ok(())
    }
}