compiler/rustc_const_eval/src/interpret/intrinsics/caller_location.rs

   1 use rustc_ast::Mutability;
   2 use rustc_hir::lang_items::LangItem;
   3 use rustc_middle::mir::TerminatorKind;
   4 use rustc_middle::ty::layout::LayoutOf;
   5 use rustc_span::{Span, Symbol};
   6
   7 use crate::interpret::{
   8     intrinsics::{InterpCx, Machine},
   9     MPlaceTy, MemoryKind, Scalar,
  10 };
  11
  12 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  13     /// Walks up the callstack from the intrinsic's callsite, searching for the first callsite in a
  14     /// frame which is not `#[track_caller]`.
  15     pub(crate) fn find_closest_untracked_caller_location(&self) -> Span {
  16         for frame in self.stack().iter().rev() {
  17             debug!("find_closest_untracked_caller_location: checking frame {:?}", frame.instance);
  18
  19             // Assert that the frame we look at is actually executing code currently
  20             // (`loc` is `Right` when we are unwinding and the frame does not require cleanup).
  21             let loc = frame.loc.left().unwrap();
  22
  23             // This could be a non-`Call` terminator (such as `Drop`), or not a terminator at all
  24             // (such as `box`). Use the normal span by default.
  25             let mut source_info = *frame.body.source_info(loc);
  26
  27             // If this is a `Call` terminator, use the `fn_span` instead.
  28             let block = &frame.body.basic_blocks[loc.block];
  29             if loc.statement_index == block.statements.len() {
  30                 debug!(
  31                     "find_closest_untracked_caller_location: got terminator {:?} ({:?})",
  32                     block.terminator(),
  33                     block.terminator().kind
  34                 );
  35                 if let TerminatorKind::Call { fn_span, .. } = block.terminator().kind {
  36                     source_info.span = fn_span;
  37                 }
  38             }
  39
  40             // Walk up the `SourceScope`s, in case some of them are from MIR inlining.
  41             // If so, the starting `source_info.span` is in the innermost inlined
  42             // function, and will be replaced with outer callsite spans as long
  43             // as the inlined functions were `#[track_caller]`.
  44             loop {
  45                 let scope_data = &frame.body.source_scopes[source_info.scope];
  46
  47                 if let Some((callee, callsite_span)) = scope_data.inlined {
  48                     // Stop inside the most nested non-`#[track_caller]` function,
  49                     // before ever reaching its caller (which is irrelevant).
  50                     if !callee.def.requires_caller_location(*self.tcx) {
  51                         return source_info.span;
  52                     }
  53                     source_info.span = callsite_span;
  54                 }
  55
  56                 // Skip past all of the parents with `inlined: None`.
  57                 match scope_data.inlined_parent_scope {
  58                     Some(parent) => source_info.scope = parent,
  59                     None => break,
  60                 }
  61             }
  62
  63             // Stop inside the most nested non-`#[track_caller]` function,
  64             // before ever reaching its caller (which is irrelevant).
  65             if !frame.instance.def.requires_caller_location(*self.tcx) {
  66                 return source_info.span;
  67             }
  68         }
  69
  70         span_bug!(self.cur_span(), "no non-`#[track_caller]` frame found")
  71     }
  72
  73     /// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.
  74     pub(crate) fn alloc_caller_location(
  75         &mut self,
  76         filename: Symbol,
  77         line: u32,
  78         col: u32,
  79     ) -> MPlaceTy<'tcx, M::Provenance> {
  80         let loc_details = &self.tcx.sess.opts.unstable_opts.location_detail;
  81         let file = if loc_details.file {
  82             self.allocate_str(filename.as_str(), MemoryKind::CallerLocation, Mutability::Not)
  83         } else {
  84             // FIXME: This creates a new allocation each time. It might be preferable to
  85             // perform this allocation only once, and re-use the `MPlaceTy`.
  86             // See https://github.com/rust-lang/rust/pull/89920#discussion_r730012398
  87             self.allocate_str("<redacted>", MemoryKind::CallerLocation, Mutability::Not)
  88         };
  89         let line = if loc_details.line { Scalar::from_u32(line) } else { Scalar::from_u32(0) };
  90         let col = if loc_details.column { Scalar::from_u32(col) } else { Scalar::from_u32(0) };
  91
  92         // Allocate memory for `CallerLocation` struct.
  93         let loc_ty = self
  94             .tcx
  95             .bound_type_of(self.tcx.require_lang_item(LangItem::PanicLocation, None))
  96             .subst(*self.tcx, self.tcx.mk_substs([self.tcx.lifetimes.re_erased.into()].iter()));
  97         let loc_layout = self.layout_of(loc_ty).unwrap();
  98         // This can fail if rustc runs out of memory right here. Trying to emit an error would be
  99         // pointless, since that would require allocating more memory than a Location.
 100         let location = self.allocate(loc_layout, MemoryKind::CallerLocation).unwrap();
 101
 102         // Initialize fields.
 103         self.write_immediate(file.to_ref(self), &self.mplace_field(&location, 0).unwrap().into())
 104             .expect("writing to memory we just allocated cannot fail");
 105         self.write_scalar(line, &self.mplace_field(&location, 1).unwrap().into())
 106             .expect("writing to memory we just allocated cannot fail");
 107         self.write_scalar(col, &self.mplace_field(&location, 2).unwrap().into())
 108             .expect("writing to memory we just allocated cannot fail");
 109
 110         location
 111     }
 112
 113     pub(crate) fn location_triple_for_span(&self, span: Span) -> (Symbol, u32, u32) {
 114         let topmost = span.ctxt().outer_expn().expansion_cause().unwrap_or(span);
 115         let caller = self.tcx.sess.source_map().lookup_char_pos(topmost.lo());
 116         (
 117             Symbol::intern(&caller.file.name.prefer_remapped().to_string_lossy()),
 118             u32::try_from(caller.line).unwrap(),
 119             u32::try_from(caller.col_display).unwrap().checked_add(1).unwrap(),
 120         )
 121     }
 122
 123     pub fn alloc_caller_location_for_span(&mut self, span: Span) -> MPlaceTy<'tcx, M::Provenance> {
 124         let (file, line, column) = self.location_triple_for_span(span);
 125         self.alloc_caller_location(file, line, column)
 126     }
 127 }