use rustc_data_structures::fx::FxHashMap;
use rustc_ast::ast::Mutability;
+use rustc_hir::def_id::DefId;
use rustc_middle::mir::AssertMessage;
use rustc_span::symbol::Symbol;
-use rustc_span::{def_id::DefId, Span};
use crate::interpret::{
self, AllocId, Allocation, GlobalId, ImmTy, InterpCx, InterpResult, Memory, MemoryKind, OpTy,
/// If this returns successfully (`Ok`), the function should just be evaluated normally.
fn hook_panic_fn(
&mut self,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx>],
) -> InterpResult<'tcx> {
let msg_place = self.deref_operand(args[0])?;
let msg = Symbol::intern(self.read_str(msg_place)?);
- let span = self.find_closest_untracked_caller_location().unwrap_or(span);
+ let span = self.find_closest_untracked_caller_location();
let (file, line, col) = self.location_triple_for_span(span);
Err(ConstEvalErrKind::Panic { msg, file, line, col }.into())
} else {
fn find_mir_or_eval_fn(
ecx: &mut InterpCx<'mir, 'tcx, Self>,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx>],
ret: Option<(PlaceTy<'tcx>, mir::BasicBlock)>,
} else {
// Some functions we support even if they are non-const -- but avoid testing
// that for const fn!
- ecx.hook_panic_fn(span, instance, args)?;
+ ecx.hook_panic_fn(instance, args)?;
// We certainly do *not* want to actually call the fn
// though, so be sure we return here.
throw_unsup_format!("calling non-const function `{}`", instance)
fn call_intrinsic(
ecx: &mut InterpCx<'mir, 'tcx, Self>,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx>],
ret: Option<(PlaceTy<'tcx>, mir::BasicBlock)>,
_unwind: Option<mir::BasicBlock>,
) -> InterpResult<'tcx> {
- if ecx.emulate_intrinsic(span, instance, args, ret)? {
+ if ecx.emulate_intrinsic(instance, args, ret)? {
return Ok(());
}
// An intrinsic that we do not support
use rustc_middle::ty::subst::SubstsRef;
use rustc_middle::ty::TyCtxt;
use rustc_span::symbol::{sym, Symbol};
-use rustc_span::Span;
use super::{ImmTy, InterpCx, Machine, OpTy, PlaceTy};
/// Returns `true` if emulation happened.
pub fn emulate_intrinsic(
&mut self,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, mir::BasicBlock)>,
// `src/librustc_middle/ty/constness.rs`
match intrinsic_name {
sym::caller_location => {
- let span = self.find_closest_untracked_caller_location().unwrap_or(span);
+ let span = self.find_closest_untracked_caller_location();
let location = self.alloc_caller_location_for_span(span);
self.write_scalar(location.ptr, dest)?;
}
sym::needs_drop => self.tcx.types.bool,
sym::type_id => self.tcx.types.u64,
sym::type_name => self.tcx.mk_static_str(),
- _ => span_bug!(span, "Already checked for nullary intrinsics"),
+ _ => bug!("already checked for nullary intrinsics"),
};
let val = self.const_eval(gid, ty)?;
self.copy_op(val, dest)?;
/// Walks up the callstack from the intrinsic's callsite, searching for the first callsite in a
/// frame which is not `#[track_caller]`. If the first frame found lacks `#[track_caller]`, then
/// `None` is returned and the callsite of the function invocation itself should be used.
- crate fn find_closest_untracked_caller_location(&self) -> Option<Span> {
- let mut caller_span = None;
- for next_caller in self.stack.iter().rev() {
- caller_span = next_caller.current_source_info().map(|si| si.span).or_else(|| caller_span);
- if !next_caller.instance.def.requires_caller_location(*self.tcx) {
- return caller_span;
- }
- }
-
- caller_span
+ crate fn find_closest_untracked_caller_location(&self) -> Span {
+ self.stack
+ .iter()
+ .rev()
+ // Skip `#[track_caller]` frames.
+ .skip_while(|frame| frame.instance.def.requires_caller_location(*self.tcx))
+ // Find next frame with source info.
+ .find_map(|frame| frame.current_source_info())
+ .map(|si| si.span)
+ // Fallback to current frame. That one has to have source_info as only
+ // currently unwinding frames without cleanup do *not* have it -- and those
+ // frames do not call this intrinsic.
+ .unwrap_or_else(|| self.frame().current_source_info().unwrap().span)
}
/// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.
use rustc_middle::mir;
use rustc_middle::ty::{self, Ty};
-use rustc_span::{def_id::DefId, Span};
+use rustc_span::def_id::DefId;
use super::{
AllocId, Allocation, AllocationExtra, Frame, ImmTy, InterpCx, InterpResult, Memory, MemoryKind,
/// was used.
fn find_mir_or_eval_fn(
ecx: &mut InterpCx<'mir, 'tcx, Self>,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx, Self::PointerTag>],
ret: Option<(PlaceTy<'tcx, Self::PointerTag>, mir::BasicBlock)>,
/// responsibility to advance the instruction pointer as appropriate.
fn call_intrinsic(
ecx: &mut InterpCx<'mir, 'tcx, Self>,
- span: Span,
instance: ty::Instance<'tcx>,
args: &[OpTy<'tcx, Self::PointerTag>],
ret: Option<(PlaceTy<'tcx, Self::PointerTag>, mir::BasicBlock)>,
use rustc_middle::ty::layout::{self, LayoutOf, TyAndLayout};
use rustc_middle::ty::Instance;
use rustc_middle::{mir, ty};
-use rustc_span::source_map::Span;
use rustc_target::spec::abi::Abi;
use super::{
Some((dest, ret)) => Some((self.eval_place(dest)?, *ret)),
None => None,
};
- self.eval_fn_call(
- fn_val,
- terminator.source_info.span,
- abi,
- &args[..],
- ret,
- *cleanup,
- )?;
+ self.eval_fn_call(fn_val, abi, &args[..], ret, *cleanup)?;
}
Drop { ref location, target, unwind } => {
trace!("TerminatorKind::drop: {:?}, type {}", location, ty);
let instance = Instance::resolve_drop_in_place(*self.tcx, ty);
- self.drop_in_place(place, instance, terminator.source_info.span, target, unwind)?;
+ self.drop_in_place(place, instance, target, unwind)?;
}
Assert { ref cond, expected, ref msg, target, cleanup } => {
fn eval_fn_call(
&mut self,
fn_val: FnVal<'tcx, M::ExtraFnVal>,
- span: Span,
caller_abi: Abi,
args: &[OpTy<'tcx, M::PointerTag>],
ret: Option<(PlaceTy<'tcx, M::PointerTag>, mir::BasicBlock)>,
match instance.def {
ty::InstanceDef::Intrinsic(..) => {
assert!(caller_abi == Abi::RustIntrinsic || caller_abi == Abi::PlatformIntrinsic);
- M::call_intrinsic(self, span, instance, args, ret, unwind)
+ M::call_intrinsic(self, instance, args, ret, unwind)
}
ty::InstanceDef::VtableShim(..)
| ty::InstanceDef::ReifyShim(..)
| ty::InstanceDef::CloneShim(..)
| ty::InstanceDef::Item(_) => {
// We need MIR for this fn
- let body = match M::find_mir_or_eval_fn(self, span, instance, args, ret, unwind)? {
+ let body = match M::find_mir_or_eval_fn(self, instance, args, ret, unwind)? {
Some(body) => body,
None => return Ok(()),
};
OpTy::from(ImmTy { layout: this_receiver_ptr, imm: receiver_place.ptr.into() });
trace!("Patched self operand to {:#?}", args[0]);
// recurse with concrete function
- self.eval_fn_call(drop_fn, span, caller_abi, &args, ret, unwind)
+ self.eval_fn_call(drop_fn, caller_abi, &args, ret, unwind)
}
}
}
&mut self,
place: PlaceTy<'tcx, M::PointerTag>,
instance: ty::Instance<'tcx>,
- span: Span,
target: mir::BasicBlock,
unwind: Option<mir::BasicBlock>,
) -> InterpResult<'tcx> {
self.eval_fn_call(
FnVal::Instance(instance),
- span,
Abi::Rust,
&[arg.into()],
Some((dest.into(), target)),
fn find_mir_or_eval_fn(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
- _span: Span,
_instance: ty::Instance<'tcx>,
_args: &[OpTy<'tcx>],
_ret: Option<(PlaceTy<'tcx>, BasicBlock)>,
fn call_intrinsic(
_ecx: &mut InterpCx<'mir, 'tcx, Self>,
- _span: Span,
_instance: ty::Instance<'tcx>,
_args: &[OpTy<'tcx>],
_ret: Option<(PlaceTy<'tcx>, BasicBlock)>,
projects / rust.git / commitdiff