}
// Push frame.
- let mir = &*this.load_mir(f.def, None)?;
+ let mir = this.load_mir(f.def, None)?;
this.push_stack_frame(f, mir, dest, stack_pop)?;
// Initialize arguments.
)
}
+ /// Helper function used inside the shims of foreign functions to assert that the target OS
+ /// is part of the UNIX family. It panics showing a message with the `name` of the foreign function
+ /// if this is not the case.
+ fn assert_target_os_is_unix(&self, name: &str) {
+ assert!(
+ target_os_is_unix(self.eval_context_ref().tcx.sess.target.os.as_ref()),
+ "`{}` is only available for supported UNIX family targets",
+ name,
+ );
+ }
+
/// Get last error variable as a place, lazily allocating thread-local storage for it if
/// necessary.
fn last_error_place(&mut self) -> InterpResult<'tcx, MPlaceTy<'tcx, Tag>> {
// FIXME: We are re-getting the allocation each time around the loop.
// Would be nice if we could somehow "extend" an existing AllocRange.
let alloc = this.get_ptr_alloc(ptr.offset(len, this)?, size1, Align::ONE)?.unwrap(); // not a ZST, so we will get a result
- let byte = alloc.read_scalar(alloc_range(Size::ZERO, size1))?.to_u8()?;
+ let byte = alloc.read_integer(Size::ZERO, size1)?.to_u8()?;
if byte == 0 {
break;
} else {
// FIXME: We are re-getting the allocation each time around the loop.
// Would be nice if we could somehow "extend" an existing AllocRange.
let alloc = this.get_ptr_alloc(ptr, size2, align2)?.unwrap(); // not a ZST, so we will get a result
- let wchar = alloc.read_scalar(alloc_range(Size::ZERO, size2))?.to_u16()?;
+ let wchar = alloc.read_integer(Size::ZERO, size2)?.to_u16()?;
if wchar == 0 {
break;
} else {
fn frame_in_std(&self) -> bool {
let this = self.eval_context_ref();
- this.tcx.lang_items().start_fn().map_or(false, |start_fn| {
- this.tcx.def_path(this.frame().instance.def_id()).krate
- == this.tcx.def_path(start_fn).krate
- })
+ let Some(start_fn) = this.tcx.lang_items().start_fn() else {
+ // no_std situations
+ return false;
+ };
+ let frame = this.frame();
+ // Make an attempt to get at the instance of the function this is inlined from.
+ let instance: Option<_> = try {
+ let scope = frame.current_source_info()?.scope;
+ let inlined_parent = frame.body.source_scopes[scope].inlined_parent_scope?;
+ let source = &frame.body.source_scopes[inlined_parent];
+ source.inlined.expect("inlined_parent_scope points to scope without inline info").0
+ };
+ // Fall back to the instance of the function itself.
+ let instance = instance.unwrap_or(frame.instance);
+ // Now check if this is in the same crate as start_fn.
+ this.tcx.def_path(instance.def_id()).krate == this.tcx.def_path(start_fn).krate
}
/// Handler that should be called when unsupported functionality is encountered.
/// topmost frame which corresponds to a local crate, and returns the current span in that frame.
/// The result of that search is cached so that later calls are approximately free.
#[derive(Clone)]
-pub struct CurrentSpan<'a, 'tcx, 'mir> {
+pub struct CurrentSpan<'a, 'mir, 'tcx> {
span: Option<Span>,
- machine: &'a Evaluator<'tcx, 'mir>,
+ machine: &'a Evaluator<'mir, 'tcx>,
}
-impl<'a, 'tcx, 'mir> CurrentSpan<'a, 'tcx, 'mir> {
+impl<'a, 'mir, 'tcx> CurrentSpan<'a, 'mir, 'tcx> {
pub fn get(&mut self) -> Span {
- *self.span.get_or_insert_with(|| Self::current_span(&self.machine))
+ *self.span.get_or_insert_with(|| Self::current_span(self.machine))
}
#[inline(never)]
machine
.threads
.active_thread_stack()
- .into_iter()
+ .iter()
.rev()
.find(|frame| {
let def_id = frame.instance.def_id();
/// Retrieve the list of local crates that should have been passed by cargo-miri in
/// MIRI_LOCAL_CRATES and turn them into `CrateNum`s.
-pub fn get_local_crates(tcx: &TyCtxt<'_>) -> Vec<CrateNum> {
+pub fn get_local_crates(tcx: TyCtxt<'_>) -> Vec<CrateNum> {
// Convert the local crate names from the passed-in config into CrateNums so that they can
// be looked up quickly during execution
let local_crate_names = std::env::var("MIRI_LOCAL_CRATES")
write!(f, "[{:#x}..{:#x}]", self.0.start.bytes(), self.0.end().bytes())
}
}
+
+/// Helper function used inside the shims of foreign functions to check that
+/// `target_os` is a supported UNIX OS.
+pub fn target_os_is_unix(target_os: &str) -> bool {
+ matches!(target_os, "linux" | "macos")
+}