src/shims/backtrace.rs

   1 use crate::*;
   2 use rustc_ast::ast::Mutability;
   3 use rustc_middle::ty::layout::LayoutOf as _;
   4 use rustc_middle::ty::{self, Instance};
   5 use rustc_span::{BytePos, Loc, Symbol};
   6 use rustc_target::{abi::Size, spec::abi::Abi};
   7
   8 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
   9 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
  10     fn handle_miri_backtrace_size(
  11         &mut self,
  12         abi: Abi,
  13         link_name: Symbol,
  14         args: &[OpTy<'tcx, Tag>],
  15         dest: &PlaceTy<'tcx, Tag>,
  16     ) -> InterpResult<'tcx> {
  17         let this = self.eval_context_mut();
  18         let [flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
  19
  20         let flags = this.read_scalar(flags)?.to_u64()?;
  21         if flags != 0 {
  22             throw_unsup_format!("unknown `miri_backtrace_size` flags {}", flags);
  23         }
  24
  25         let frame_count = this.active_thread_stack().len();
  26
  27         this.write_scalar(Scalar::from_machine_usize(frame_count.try_into().unwrap(), this), dest)
  28     }
  29
  30     fn handle_miri_get_backtrace(
  31         &mut self,
  32         abi: Abi,
  33         link_name: Symbol,
  34         args: &[OpTy<'tcx, Tag>],
  35         dest: &PlaceTy<'tcx, Tag>,
  36     ) -> InterpResult<'tcx> {
  37         let this = self.eval_context_mut();
  38         let tcx = this.tcx;
  39
  40         let flags = if let Some(flags_op) = args.get(0) {
  41             this.read_scalar(flags_op)?.to_u64()?
  42         } else {
  43             throw_ub_format!("expected at least 1 argument")
  44         };
  45
  46         let mut data = Vec::new();
  47         for frame in this.active_thread_stack().iter().rev() {
  48             let mut span = frame.current_span();
  49             // Match the behavior of runtime backtrace spans
  50             // by using a non-macro span in our backtrace. See `FunctionCx::debug_loc`.
  51             if span.from_expansion() && !tcx.sess.opts.debugging_opts.debug_macros {
  52                 span = rustc_span::hygiene::walk_chain(span, frame.body.span.ctxt())
  53             }
  54             data.push((frame.instance, span.lo()));
  55         }
  56
  57         let ptrs: Vec<_> = data
  58             .into_iter()
  59             .map(|(instance, pos)| {
  60                 // We represent a frame pointer by using the `span.lo` value
  61                 // as an offset into the function's allocation. This gives us an
  62                 // opaque pointer that we can return to user code, and allows us
  63                 // to reconstruct the needed frame information in `handle_miri_resolve_frame`.
  64                 // Note that we never actually read or write anything from/to this pointer -
  65                 // all of the data is represented by the pointer value itself.
  66                 let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(instance));
  67                 fn_ptr.wrapping_offset(Size::from_bytes(pos.0), this)
  68             })
  69             .collect();
  70
  71         let len: u64 = ptrs.len().try_into().unwrap();
  72
  73         let ptr_ty = this.machine.layouts.mut_raw_ptr.ty;
  74         let array_layout = this.layout_of(tcx.mk_array(ptr_ty, len)).unwrap();
  75
  76         match flags {
  77             // storage for pointers is allocated by miri
  78             // deallocating the slice is undefined behavior with a custom global allocator
  79             0 => {
  80                 let [_flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
  81
  82                 let alloc = this.allocate(array_layout, MiriMemoryKind::Rust.into())?;
  83
  84                 // Write pointers into array
  85                 for (i, ptr) in ptrs.into_iter().enumerate() {
  86                     let place = this.mplace_index(&alloc, i as u64)?;
  87
  88                     this.write_pointer(ptr, &place.into())?;
  89                 }
  90
  91                 this.write_immediate(
  92                     Immediate::new_slice(Scalar::from_maybe_pointer(alloc.ptr, this), len, this),
  93                     dest,
  94                 )?;
  95             }
  96             // storage for pointers is allocated by the caller
  97             1 => {
  98                 let [_flags, buf] = this.check_shim(abi, Abi::Rust, link_name, args)?;
  99
 100                 let buf_place = this.deref_operand(buf)?;
 101
 102                 let ptr_layout = this.layout_of(ptr_ty)?;
 103
 104                 for (i, ptr) in ptrs.into_iter().enumerate() {
 105                     let offset = ptr_layout.size * i.try_into().unwrap();
 106
 107                     let op_place =
 108                         buf_place.offset(offset, MemPlaceMeta::None, ptr_layout, this)?;
 109
 110                     this.write_pointer(ptr, &op_place.into())?;
 111                 }
 112             }
 113             _ => throw_unsup_format!("unknown `miri_get_backtrace` flags {}", flags),
 114         };
 115
 116         Ok(())
 117     }
 118
 119     fn resolve_frame_pointer(
 120         &mut self,
 121         ptr: &OpTy<'tcx, Tag>,
 122     ) -> InterpResult<'tcx, (Instance<'tcx>, Loc, String, String)> {
 123         let this = self.eval_context_mut();
 124
 125         let ptr = this.read_pointer(ptr)?;
 126         // Take apart the pointer, we need its pieces.
 127         let (alloc_id, offset, _tag) = this.ptr_get_alloc_id(ptr)?;
 128
 129         let fn_instance =
 130             if let Some(GlobalAlloc::Function(instance)) = this.tcx.get_global_alloc(alloc_id) {
 131                 instance
 132             } else {
 133                 throw_ub_format!("expected function pointer, found {:?}", ptr);
 134             };
 135
 136         let lo =
 137             this.tcx.sess.source_map().lookup_char_pos(BytePos(offset.bytes().try_into().unwrap()));
 138
 139         let name = fn_instance.to_string();
 140         let filename = lo.file.name.prefer_remapped().to_string();
 141
 142         Ok((fn_instance, lo, name, filename))
 143     }
 144
 145     fn handle_miri_resolve_frame(
 146         &mut self,
 147         abi: Abi,
 148         link_name: Symbol,
 149         args: &[OpTy<'tcx, Tag>],
 150         dest: &PlaceTy<'tcx, Tag>,
 151     ) -> InterpResult<'tcx> {
 152         let this = self.eval_context_mut();
 153         let [ptr, flags] = this.check_shim(abi, Abi::Rust, link_name, args)?;
 154
 155         let flags = this.read_scalar(flags)?.to_u64()?;
 156
 157         let (fn_instance, lo, name, filename) = this.resolve_frame_pointer(ptr)?;
 158
 159         // Reconstruct the original function pointer,
 160         // which we pass to user code.
 161         let fn_ptr = this.create_fn_alloc_ptr(FnVal::Instance(fn_instance));
 162
 163         let num_fields = dest.layout.fields.count();
 164
 165         if !(4..=5).contains(&num_fields) {
 166             // Always mention 5 fields, since the 4-field struct
 167             // is deprecated and slated for removal.
 168             throw_ub_format!(
 169                 "bad declaration of miri_resolve_frame - should return a struct with 5 fields"
 170             );
 171         }
 172
 173         let lineno: u32 = lo.line as u32;
 174         // `lo.col` is 0-based - add 1 to make it 1-based for the caller.
 175         let colno: u32 = lo.col.0 as u32 + 1;
 176
 177         let dest = this.force_allocation(dest)?;
 178         if let ty::Adt(adt, _) = dest.layout.ty.kind() {
 179             if !adt.repr().c() {
 180                 throw_ub_format!(
 181                     "miri_resolve_frame must be declared with a `#[repr(C)]` return type"
 182                 );
 183             }
 184         }
 185
 186         match flags {
 187             0 => {
 188                 // These are "mutable" allocations as we consider them to be owned by the callee.
 189                 let name_alloc =
 190                     this.allocate_str(&name, MiriMemoryKind::Rust.into(), Mutability::Mut);
 191                 let filename_alloc =
 192                     this.allocate_str(&filename, MiriMemoryKind::Rust.into(), Mutability::Mut);
 193
 194                 this.write_immediate(
 195                     name_alloc.to_ref(this),
 196                     &this.mplace_field(&dest, 0)?.into(),
 197                 )?;
 198                 this.write_immediate(
 199                     filename_alloc.to_ref(this),
 200                     &this.mplace_field(&dest, 1)?.into(),
 201                 )?;
 202             }
 203             1 => {
 204                 this.write_scalar(
 205                     Scalar::from_machine_usize(name.len().try_into().unwrap(), this),
 206                     &this.mplace_field(&dest, 0)?.into(),
 207                 )?;
 208                 this.write_scalar(
 209                     Scalar::from_machine_usize(filename.len().try_into().unwrap(), this),
 210                     &this.mplace_field(&dest, 1)?.into(),
 211                 )?;
 212             }
 213             _ => throw_unsup_format!("unknown `miri_resolve_frame` flags {}", flags),
 214         }
 215
 216         this.write_scalar(Scalar::from_u32(lineno), &this.mplace_field(&dest, 2)?.into())?;
 217         this.write_scalar(Scalar::from_u32(colno), &this.mplace_field(&dest, 3)?.into())?;
 218
 219         // Support a 4-field struct for now - this is deprecated
 220         // and slated for removal.
 221         if num_fields == 5 {
 222             this.write_pointer(fn_ptr, &this.mplace_field(&dest, 4)?.into())?;
 223         }
 224
 225         Ok(())
 226     }
 227
 228     fn handle_miri_resolve_frame_names(
 229         &mut self,
 230         abi: Abi,
 231         link_name: Symbol,
 232         args: &[OpTy<'tcx, Tag>],
 233     ) -> InterpResult<'tcx> {
 234         let this = self.eval_context_mut();
 235
 236         let [ptr, flags, name_ptr, filename_ptr] =
 237             this.check_shim(abi, Abi::Rust, link_name, args)?;
 238
 239         let flags = this.read_scalar(flags)?.to_u64()?;
 240         if flags != 0 {
 241             throw_unsup_format!("unknown `miri_resolve_frame_names` flags {}", flags);
 242         }
 243
 244         let (_, _, name, filename) = this.resolve_frame_pointer(ptr)?;
 245
 246         this.write_bytes_ptr(this.read_pointer(name_ptr)?, name.bytes())?;
 247         this.write_bytes_ptr(this.read_pointer(filename_ptr)?, filename.bytes())?;
 248
 249         Ok(())
 250     }
 251 }