1use std::num::NonZero;
2use std::time::Duration;
3use std::{cmp, iter};
4
5use rand::RngCore;
6use rustc_abi::{Align, ExternAbi, FieldIdx, FieldsShape, Size, Variants};
7use rustc_apfloat::Float;
8use rustc_apfloat::ieee::{Double, Half, Quad, Single};
9use rustc_hir::Safety;
10use rustc_hir::def::{DefKind, Namespace};
11use rustc_hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefId, LOCAL_CRATE};
12use rustc_index::IndexVec;
13use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
14use rustc_middle::middle::dependency_format::Linkage;
15use rustc_middle::middle::exported_symbols::ExportedSymbol;
16use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, MaybeResult, TyAndLayout};
17use rustc_middle::ty::{self, Binder, FloatTy, FnSig, IntTy, Ty, TyCtxt, UintTy};
18use rustc_session::config::CrateType;
19use rustc_span::{Span, Symbol};
20use rustc_symbol_mangling::mangle_internal_symbol;
21use rustc_target::callconv::{Conv, FnAbi};
22
23use crate::*;
24
25#[derive(Copy, Clone, Hash, PartialEq, Eq, Debug)]
27pub enum AccessKind {
28 Read,
29 Write,
30}
31
32fn try_resolve_did(tcx: TyCtxt<'_>, path: &[&str], namespace: Option<Namespace>) -> Option<DefId> {
36 fn find_children<'tcx: 'a, 'a>(
38 tcx: TyCtxt<'tcx>,
39 item: DefId,
40 name: &'a str,
41 ) -> impl Iterator<Item = DefId> + 'a {
42 let name = Symbol::intern(name);
43 tcx.module_children(item)
44 .iter()
45 .filter(move |item| item.ident.name == name)
46 .map(move |item| item.res.def_id())
47 }
48
49 let (&crate_name, path) = path.split_first().expect("paths must have at least one segment");
51 let (modules, item) = if let Some(namespace) = namespace {
52 let (&item_name, modules) =
53 path.split_last().expect("non-module paths must have at least 2 segments");
54 (modules, Some((item_name, namespace)))
55 } else {
56 (path, None)
57 };
58
59 'crates: for krate in
64 tcx.crates(()).iter().filter(|&&krate| tcx.crate_name(krate).as_str() == crate_name)
65 {
66 let mut cur_item = DefId { krate: *krate, index: CRATE_DEF_INDEX };
67 for &segment in modules {
69 let Some(next_item) = find_children(tcx, cur_item, segment)
70 .find(|item| tcx.def_kind(item) == DefKind::Mod)
71 else {
72 continue 'crates;
73 };
74 cur_item = next_item;
75 }
76 match item {
78 Some((item_name, namespace)) => {
79 let Some(item) = find_children(tcx, cur_item, item_name)
80 .find(|item| tcx.def_kind(item).ns() == Some(namespace))
81 else {
82 continue 'crates;
83 };
84 return Some(item);
85 }
86 None => {
87 return Some(cur_item);
89 }
90 }
91 }
92 None
94}
95
96pub fn try_resolve_path<'tcx>(
98 tcx: TyCtxt<'tcx>,
99 path: &[&str],
100 namespace: Namespace,
101) -> Option<ty::Instance<'tcx>> {
102 let did = try_resolve_did(tcx, path, Some(namespace))?;
103 Some(ty::Instance::mono(tcx, did))
104}
105
106#[track_caller]
108pub fn resolve_path<'tcx>(
109 tcx: TyCtxt<'tcx>,
110 path: &[&str],
111 namespace: Namespace,
112) -> ty::Instance<'tcx> {
113 try_resolve_path(tcx, path, namespace)
114 .unwrap_or_else(|| panic!("failed to find required Rust item: {path:?}"))
115}
116
117#[track_caller]
119pub fn path_ty_layout<'tcx>(cx: &impl LayoutOf<'tcx>, path: &[&str]) -> TyAndLayout<'tcx> {
120 let ty = resolve_path(cx.tcx(), path, Namespace::TypeNS).ty(cx.tcx(), cx.typing_env());
121 cx.layout_of(ty).to_result().ok().unwrap()
122}
123
124pub fn iter_exported_symbols<'tcx>(
126 tcx: TyCtxt<'tcx>,
127 mut f: impl FnMut(CrateNum, DefId) -> InterpResult<'tcx>,
128) -> InterpResult<'tcx> {
129 let crate_items = tcx.hir_crate_items(());
133 for def_id in crate_items.definitions() {
134 let exported = tcx.def_kind(def_id).has_codegen_attrs() && {
135 let codegen_attrs = tcx.codegen_fn_attrs(def_id);
136 codegen_attrs.contains_extern_indicator()
137 || codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
138 || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED)
139 || codegen_attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER)
140 };
141 if exported {
142 f(LOCAL_CRATE, def_id.into())?;
143 }
144 }
145
146 let dependency_formats = tcx.dependency_formats(());
151 let dependency_format = dependency_formats
153 .get(&CrateType::Executable)
154 .expect("interpreting a non-executable crate");
155 for cnum in dependency_format
156 .iter_enumerated()
157 .filter_map(|(num, &linkage)| (linkage != Linkage::NotLinked).then_some(num))
158 {
159 if cnum == LOCAL_CRATE {
160 continue; }
162
163 for &(symbol, _export_info) in tcx.exported_symbols(cnum) {
166 if let ExportedSymbol::NonGeneric(def_id) = symbol {
167 f(cnum, def_id)?;
168 }
169 }
170 }
171 interp_ok(())
172}
173
174pub trait ToHost {
176 type HostFloat;
177 fn to_host(self) -> Self::HostFloat;
178}
179
180pub trait ToSoft {
182 type SoftFloat;
183 fn to_soft(self) -> Self::SoftFloat;
184}
185
186impl ToHost for rustc_apfloat::ieee::Double {
187 type HostFloat = f64;
188
189 fn to_host(self) -> Self::HostFloat {
190 f64::from_bits(self.to_bits().try_into().unwrap())
191 }
192}
193
194impl ToSoft for f64 {
195 type SoftFloat = rustc_apfloat::ieee::Double;
196
197 fn to_soft(self) -> Self::SoftFloat {
198 Float::from_bits(self.to_bits().into())
199 }
200}
201
202impl ToHost for rustc_apfloat::ieee::Single {
203 type HostFloat = f32;
204
205 fn to_host(self) -> Self::HostFloat {
206 f32::from_bits(self.to_bits().try_into().unwrap())
207 }
208}
209
210impl ToSoft for f32 {
211 type SoftFloat = rustc_apfloat::ieee::Single;
212
213 fn to_soft(self) -> Self::SoftFloat {
214 Float::from_bits(self.to_bits().into())
215 }
216}
217
218impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
219pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
220 fn have_module(&self, path: &[&str]) -> bool {
222 try_resolve_did(*self.eval_context_ref().tcx, path, None).is_some()
223 }
224
225 fn eval_path(&self, path: &[&str]) -> MPlaceTy<'tcx> {
227 let this = self.eval_context_ref();
228 let instance = resolve_path(*this.tcx, path, Namespace::ValueNS);
229 this.eval_global(instance).unwrap_or_else(|err| {
231 panic!("failed to evaluate required Rust item: {path:?}\n{err:?}")
232 })
233 }
234 fn eval_path_scalar(&self, path: &[&str]) -> Scalar {
235 let this = self.eval_context_ref();
236 let val = this.eval_path(path);
237 this.read_scalar(&val)
238 .unwrap_or_else(|err| panic!("failed to read required Rust item: {path:?}\n{err:?}"))
239 }
240
241 fn eval_libc(&self, name: &str) -> Scalar {
243 if self.eval_context_ref().tcx.sess.target.os == "windows" {
244 panic!(
245 "`libc` crate is not reliably available on Windows targets; Miri should not use it there"
246 );
247 }
248 self.eval_path_scalar(&["libc", name])
249 }
250
251 fn eval_libc_i32(&self, name: &str) -> i32 {
253 self.eval_libc(name).to_i32().unwrap_or_else(|_err| {
255 panic!("required libc item has unexpected type (not `i32`): {name}")
256 })
257 }
258
259 fn eval_libc_u32(&self, name: &str) -> u32 {
261 self.eval_libc(name).to_u32().unwrap_or_else(|_err| {
263 panic!("required libc item has unexpected type (not `u32`): {name}")
264 })
265 }
266
267 fn eval_libc_u64(&self, name: &str) -> u64 {
269 self.eval_libc(name).to_u64().unwrap_or_else(|_err| {
271 panic!("required libc item has unexpected type (not `u64`): {name}")
272 })
273 }
274
275 fn eval_windows(&self, module: &str, name: &str) -> Scalar {
277 self.eval_context_ref().eval_path_scalar(&["std", "sys", "pal", "windows", module, name])
278 }
279
280 fn eval_windows_u32(&self, module: &str, name: &str) -> u32 {
282 self.eval_windows(module, name).to_u32().unwrap_or_else(|_err| {
284 panic!("required Windows item has unexpected type (not `u32`): {module}::{name}")
285 })
286 }
287
288 fn eval_windows_u64(&self, module: &str, name: &str) -> u64 {
290 self.eval_windows(module, name).to_u64().unwrap_or_else(|_err| {
292 panic!("required Windows item has unexpected type (not `u64`): {module}::{name}")
293 })
294 }
295
296 fn libc_ty_layout(&self, name: &str) -> TyAndLayout<'tcx> {
298 let this = self.eval_context_ref();
299 if this.tcx.sess.target.os == "windows" {
300 panic!(
301 "`libc` crate is not reliably available on Windows targets; Miri should not use it there"
302 );
303 }
304 path_ty_layout(this, &["libc", name])
305 }
306
307 fn windows_ty_layout(&self, name: &str) -> TyAndLayout<'tcx> {
309 let this = self.eval_context_ref();
310 path_ty_layout(this, &["std", "sys", "pal", "windows", "c", name])
311 }
312
313 fn libc_array_ty_layout(&self, name: &str, size: u64) -> TyAndLayout<'tcx> {
315 let this = self.eval_context_ref();
316 let elem_ty_layout = this.libc_ty_layout(name);
317 let array_ty = Ty::new_array(*this.tcx, elem_ty_layout.ty, size);
318 this.layout_of(array_ty).unwrap()
319 }
320
321 fn try_project_field_named<P: Projectable<'tcx, Provenance>>(
323 &self,
324 base: &P,
325 name: &str,
326 ) -> InterpResult<'tcx, Option<P>> {
327 let this = self.eval_context_ref();
328 let adt = base.layout().ty.ty_adt_def().unwrap();
329 for (idx, field) in adt.non_enum_variant().fields.iter().enumerate() {
330 if field.name.as_str() == name {
331 return interp_ok(Some(this.project_field(base, idx)?));
332 }
333 }
334 interp_ok(None)
335 }
336
337 fn project_field_named<P: Projectable<'tcx, Provenance>>(
339 &self,
340 base: &P,
341 name: &str,
342 ) -> InterpResult<'tcx, P> {
343 interp_ok(
344 self.try_project_field_named(base, name)?
345 .unwrap_or_else(|| bug!("no field named {} in type {}", name, base.layout().ty)),
346 )
347 }
348
349 fn write_int(
353 &mut self,
354 i: impl Into<i128>,
355 dest: &impl Writeable<'tcx, Provenance>,
356 ) -> InterpResult<'tcx> {
357 assert!(
358 dest.layout().backend_repr.is_scalar(),
359 "write_int on non-scalar type {}",
360 dest.layout().ty
361 );
362 let val = if dest.layout().backend_repr.is_signed() {
363 Scalar::from_int(i, dest.layout().size)
364 } else {
365 Scalar::from_uint(u128::try_from(i.into()).unwrap(), dest.layout().size)
367 };
368 self.eval_context_mut().write_scalar(val, dest)
369 }
370
371 fn write_int_fields(
373 &mut self,
374 values: &[i128],
375 dest: &impl Writeable<'tcx, Provenance>,
376 ) -> InterpResult<'tcx> {
377 let this = self.eval_context_mut();
378 for (idx, &val) in values.iter().enumerate() {
379 let field = this.project_field(dest, idx)?;
380 this.write_int(val, &field)?;
381 }
382 interp_ok(())
383 }
384
385 fn write_int_fields_named(
387 &mut self,
388 values: &[(&str, i128)],
389 dest: &impl Writeable<'tcx, Provenance>,
390 ) -> InterpResult<'tcx> {
391 let this = self.eval_context_mut();
392 for &(name, val) in values.iter() {
393 let field = this.project_field_named(dest, name)?;
394 this.write_int(val, &field)?;
395 }
396 interp_ok(())
397 }
398
399 fn write_null(&mut self, dest: &impl Writeable<'tcx, Provenance>) -> InterpResult<'tcx> {
401 self.write_int(0, dest)
402 }
403
404 fn ptr_is_null(&self, ptr: Pointer) -> InterpResult<'tcx, bool> {
406 interp_ok(ptr.addr().bytes() == 0)
407 }
408
409 fn gen_random(&mut self, ptr: Pointer, len: u64) -> InterpResult<'tcx> {
411 if len == 0 {
417 return interp_ok(());
418 }
419 let this = self.eval_context_mut();
420
421 let mut data = vec![0; usize::try_from(len).unwrap()];
422
423 if this.machine.communicate() {
424 getrandom::fill(&mut data)
426 .map_err(|err| err_unsup_format!("host getrandom failed: {}", err))?;
427 } else {
428 let rng = this.machine.rng.get_mut();
429 rng.fill_bytes(&mut data);
430 }
431
432 this.write_bytes_ptr(ptr, data.iter().copied())
433 }
434
435 fn call_function(
441 &mut self,
442 f: ty::Instance<'tcx>,
443 caller_abi: ExternAbi,
444 args: &[ImmTy<'tcx>],
445 dest: Option<&MPlaceTy<'tcx>>,
446 stack_pop: StackPopCleanup,
447 ) -> InterpResult<'tcx> {
448 let this = self.eval_context_mut();
449
450 let mir = this.load_mir(f.def, None)?;
452 let dest = match dest {
453 Some(dest) => dest.clone(),
454 None => MPlaceTy::fake_alloc_zst(this.layout_of(mir.return_ty())?),
455 };
456
457 let sig = this.tcx.mk_fn_sig(
459 args.iter().map(|a| a.layout.ty),
460 dest.layout.ty,
461 false,
462 Safety::Safe,
463 caller_abi,
464 );
465 let caller_fn_abi = this.fn_abi_of_fn_ptr(ty::Binder::dummy(sig), ty::List::empty())?;
466
467 this.init_stack_frame(
468 f,
469 mir,
470 caller_fn_abi,
471 &args.iter().map(|a| FnArg::Copy(a.clone().into())).collect::<Vec<_>>(),
472 false,
473 &dest,
474 stack_pop,
475 )
476 }
477
478 fn visit_freeze_sensitive(
482 &self,
483 place: &MPlaceTy<'tcx>,
484 size: Size,
485 mut action: impl FnMut(AllocRange, bool) -> InterpResult<'tcx>,
486 ) -> InterpResult<'tcx> {
487 let this = self.eval_context_ref();
488 trace!("visit_frozen(place={:?}, size={:?})", *place, size);
489 debug_assert_eq!(
490 size,
491 this.size_and_align_of_mplace(place)?
492 .map(|(size, _)| size)
493 .unwrap_or_else(|| place.layout.size)
494 );
495 let start_addr = place.ptr().addr();
499 let mut cur_addr = start_addr;
500 let mut unsafe_cell_action = |unsafe_cell_ptr: &Pointer, unsafe_cell_size: Size| {
503 let unsafe_cell_addr = unsafe_cell_ptr.addr();
506 assert!(unsafe_cell_addr >= cur_addr);
507 let frozen_size = unsafe_cell_addr - cur_addr;
508 if frozen_size != Size::ZERO {
510 action(alloc_range(cur_addr - start_addr, frozen_size), true)?;
511 }
512 cur_addr += frozen_size;
513 if unsafe_cell_size != Size::ZERO {
515 action(
516 alloc_range(cur_addr - start_addr, unsafe_cell_size),
517 false,
518 )?;
519 }
520 cur_addr += unsafe_cell_size;
521 interp_ok(())
523 };
524 {
526 let mut visitor = UnsafeCellVisitor {
527 ecx: this,
528 unsafe_cell_action: |place| {
529 trace!("unsafe_cell_action on {:?}", place.ptr());
530 let unsafe_cell_size = this
532 .size_and_align_of_mplace(place)?
533 .map(|(size, _)| size)
534 .unwrap_or_else(|| place.layout.size);
536 if unsafe_cell_size != Size::ZERO {
538 unsafe_cell_action(&place.ptr(), unsafe_cell_size)
539 } else {
540 interp_ok(())
541 }
542 },
543 };
544 visitor.visit_value(place)?;
545 }
546 unsafe_cell_action(&place.ptr().wrapping_offset(size, this), Size::ZERO)?;
549 return interp_ok(());
551
552 struct UnsafeCellVisitor<'ecx, 'tcx, F>
555 where
556 F: FnMut(&MPlaceTy<'tcx>) -> InterpResult<'tcx>,
557 {
558 ecx: &'ecx MiriInterpCx<'tcx>,
559 unsafe_cell_action: F,
560 }
561
562 impl<'ecx, 'tcx, F> ValueVisitor<'tcx, MiriMachine<'tcx>> for UnsafeCellVisitor<'ecx, 'tcx, F>
563 where
564 F: FnMut(&MPlaceTy<'tcx>) -> InterpResult<'tcx>,
565 {
566 type V = MPlaceTy<'tcx>;
567
568 #[inline(always)]
569 fn ecx(&self) -> &MiriInterpCx<'tcx> {
570 self.ecx
571 }
572
573 fn aggregate_field_iter(
574 memory_index: &IndexVec<FieldIdx, u32>,
575 ) -> impl Iterator<Item = FieldIdx> + 'static {
576 let inverse_memory_index = memory_index.invert_bijective_mapping();
577 inverse_memory_index.into_iter()
578 }
579
580 fn visit_value(&mut self, v: &MPlaceTy<'tcx>) -> InterpResult<'tcx> {
582 trace!("UnsafeCellVisitor: {:?} {:?}", *v, v.layout.ty);
583 let is_unsafe_cell = match v.layout.ty.kind() {
584 ty::Adt(adt, _) =>
585 Some(adt.did()) == self.ecx.tcx.lang_items().unsafe_cell_type(),
586 _ => false,
587 };
588 if is_unsafe_cell {
589 (self.unsafe_cell_action)(v)
591 } else if self.ecx.type_is_freeze(v.layout.ty) {
592 interp_ok(())
594 } else if matches!(v.layout.fields, FieldsShape::Union(..)) {
595 (self.unsafe_cell_action)(v)
597 } else if matches!(v.layout.ty.kind(), ty::Dynamic(_, _, ty::DynStar)) {
598 (self.unsafe_cell_action)(v)
601 } else {
602 match v.layout.variants {
609 Variants::Multiple { .. } => {
610 (self.unsafe_cell_action)(v)
618 }
619 Variants::Single { .. } | Variants::Empty => {
620 self.walk_value(v)
623 }
624 }
625 }
626 }
627
628 fn visit_union(
629 &mut self,
630 _v: &MPlaceTy<'tcx>,
631 _fields: NonZero<usize>,
632 ) -> InterpResult<'tcx> {
633 bug!("we should have already handled unions in `visit_value`")
634 }
635 }
636 }
637
638 fn check_no_isolation(&self, name: &str) -> InterpResult<'tcx> {
642 if !self.eval_context_ref().machine.communicate() {
643 self.reject_in_isolation(name, RejectOpWith::Abort)?;
644 }
645 interp_ok(())
646 }
647
648 fn reject_in_isolation(&self, op_name: &str, reject_with: RejectOpWith) -> InterpResult<'tcx> {
651 let this = self.eval_context_ref();
652 match reject_with {
653 RejectOpWith::Abort => isolation_abort_error(op_name),
654 RejectOpWith::WarningWithoutBacktrace => {
655 let mut emitted_warnings = this.machine.reject_in_isolation_warned.borrow_mut();
656 if !emitted_warnings.contains(op_name) {
657 emitted_warnings.insert(op_name.to_owned());
659 this.tcx
660 .dcx()
661 .warn(format!("{op_name} was made to return an error due to isolation"));
662 }
663
664 interp_ok(())
665 }
666 RejectOpWith::Warning => {
667 this.emit_diagnostic(NonHaltingDiagnostic::RejectedIsolatedOp(op_name.to_string()));
668 interp_ok(())
669 }
670 RejectOpWith::NoWarning => interp_ok(()), }
672 }
673
674 fn assert_target_os(&self, target_os: &str, name: &str) {
678 assert_eq!(
679 self.eval_context_ref().tcx.sess.target.os,
680 target_os,
681 "`{name}` is only available on the `{target_os}` target OS",
682 )
683 }
684
685 fn check_target_os(&self, target_oses: &[&str], name: Symbol) -> InterpResult<'tcx> {
689 let target_os = self.eval_context_ref().tcx.sess.target.os.as_ref();
690 if !target_oses.contains(&target_os) {
691 throw_unsup_format!("`{name}` is not supported on {target_os}");
692 }
693 interp_ok(())
694 }
695
696 fn assert_target_os_is_unix(&self, name: &str) {
700 assert!(self.target_os_is_unix(), "`{name}` is only available for unix targets",);
701 }
702
703 fn target_os_is_unix(&self) -> bool {
704 self.eval_context_ref().tcx.sess.target.families.iter().any(|f| f == "unix")
705 }
706
707 fn deref_pointer_as(
709 &self,
710 op: &impl Projectable<'tcx, Provenance>,
711 layout: TyAndLayout<'tcx>,
712 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
713 let this = self.eval_context_ref();
714 let ptr = this.read_pointer(op)?;
715 interp_ok(this.ptr_to_mplace(ptr, layout))
716 }
717
718 fn deref_pointer_and_offset(
720 &self,
721 op: &impl Projectable<'tcx, Provenance>,
722 offset: u64,
723 base_layout: TyAndLayout<'tcx>,
724 value_layout: TyAndLayout<'tcx>,
725 ) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
726 let this = self.eval_context_ref();
727 let op_place = this.deref_pointer_as(op, base_layout)?;
728 let offset = Size::from_bytes(offset);
729
730 assert!(base_layout.size >= offset + value_layout.size);
732 let value_place = op_place.offset(offset, value_layout, this)?;
733 interp_ok(value_place)
734 }
735
736 fn deref_pointer_and_read(
737 &self,
738 op: &impl Projectable<'tcx, Provenance>,
739 offset: u64,
740 base_layout: TyAndLayout<'tcx>,
741 value_layout: TyAndLayout<'tcx>,
742 ) -> InterpResult<'tcx, Scalar> {
743 let this = self.eval_context_ref();
744 let value_place = this.deref_pointer_and_offset(op, offset, base_layout, value_layout)?;
745 this.read_scalar(&value_place)
746 }
747
748 fn deref_pointer_and_write(
749 &mut self,
750 op: &impl Projectable<'tcx, Provenance>,
751 offset: u64,
752 value: impl Into<Scalar>,
753 base_layout: TyAndLayout<'tcx>,
754 value_layout: TyAndLayout<'tcx>,
755 ) -> InterpResult<'tcx, ()> {
756 let this = self.eval_context_mut();
757 let value_place = this.deref_pointer_and_offset(op, offset, base_layout, value_layout)?;
758 this.write_scalar(value, &value_place)
759 }
760
761 fn read_timespec(&mut self, tp: &MPlaceTy<'tcx>) -> InterpResult<'tcx, Option<Duration>> {
765 let this = self.eval_context_mut();
766 let seconds_place = this.project_field(tp, 0)?;
767 let seconds_scalar = this.read_scalar(&seconds_place)?;
768 let seconds = seconds_scalar.to_target_isize(this)?;
769 let nanoseconds_place = this.project_field(tp, 1)?;
770 let nanoseconds_scalar = this.read_scalar(&nanoseconds_place)?;
771 let nanoseconds = nanoseconds_scalar.to_target_isize(this)?;
772
773 interp_ok(
774 try {
775 let seconds: u64 = seconds.try_into().ok()?;
777 let nanoseconds: u32 = nanoseconds.try_into().ok()?;
779 if nanoseconds >= 1_000_000_000 {
780 None?
782 }
783 Duration::new(seconds, nanoseconds)
784 },
785 )
786 }
787
788 fn read_byte_slice<'a>(&'a self, slice: &ImmTy<'tcx>) -> InterpResult<'tcx, &'a [u8]>
790 where
791 'tcx: 'a,
792 {
793 let this = self.eval_context_ref();
794 let (ptr, len) = slice.to_scalar_pair();
795 let ptr = ptr.to_pointer(this)?;
796 let len = len.to_target_usize(this)?;
797 let bytes = this.read_bytes_ptr_strip_provenance(ptr, Size::from_bytes(len))?;
798 interp_ok(bytes)
799 }
800
801 fn read_c_str<'a>(&'a self, ptr: Pointer) -> InterpResult<'tcx, &'a [u8]>
803 where
804 'tcx: 'a,
805 {
806 let this = self.eval_context_ref();
807 let size1 = Size::from_bytes(1);
808
809 let mut len = Size::ZERO;
811 loop {
812 let alloc = this.get_ptr_alloc(ptr.wrapping_offset(len, this), size1)?.unwrap(); let byte = alloc.read_integer(alloc_range(Size::ZERO, size1))?.to_u8()?;
816 if byte == 0 {
817 break;
818 } else {
819 len += size1;
820 }
821 }
822
823 this.read_bytes_ptr_strip_provenance(ptr, len)
825 }
826
827 fn write_c_str(
833 &mut self,
834 c_str: &[u8],
835 ptr: Pointer,
836 size: u64,
837 ) -> InterpResult<'tcx, (bool, u64)> {
838 let string_length = u64::try_from(c_str.len()).unwrap();
841 let string_length = string_length.strict_add(1);
842 if size < string_length {
843 return interp_ok((false, string_length));
844 }
845 self.eval_context_mut()
846 .write_bytes_ptr(ptr, c_str.iter().copied().chain(iter::once(0u8)))?;
847 interp_ok((true, string_length))
848 }
849
850 fn read_c_str_with_char_size<T>(
853 &self,
854 mut ptr: Pointer,
855 size: Size,
856 align: Align,
857 ) -> InterpResult<'tcx, Vec<T>>
858 where
859 T: TryFrom<u128>,
860 <T as TryFrom<u128>>::Error: std::fmt::Debug,
861 {
862 assert_ne!(size, Size::ZERO);
863
864 let this = self.eval_context_ref();
865
866 this.check_ptr_align(ptr, align)?;
867
868 let mut wchars = Vec::new();
869 loop {
870 let alloc = this.get_ptr_alloc(ptr, size)?.unwrap(); let wchar_int = alloc.read_integer(alloc_range(Size::ZERO, size))?.to_bits(size)?;
874 if wchar_int == 0 {
875 break;
876 } else {
877 wchars.push(wchar_int.try_into().unwrap());
878 ptr = ptr.wrapping_offset(size, this);
879 }
880 }
881
882 interp_ok(wchars)
883 }
884
885 fn read_wide_str(&self, ptr: Pointer) -> InterpResult<'tcx, Vec<u16>> {
887 self.read_c_str_with_char_size(ptr, Size::from_bytes(2), Align::from_bytes(2).unwrap())
888 }
889
890 fn write_wide_str(
897 &mut self,
898 wide_str: &[u16],
899 ptr: Pointer,
900 size: u64,
901 ) -> InterpResult<'tcx, (bool, u64)> {
902 let string_length = u64::try_from(wide_str.len()).unwrap();
905 let string_length = string_length.strict_add(1);
906 if size < string_length {
907 return interp_ok((false, string_length));
908 }
909
910 let size2 = Size::from_bytes(2);
912 let this = self.eval_context_mut();
913 this.check_ptr_align(ptr, Align::from_bytes(2).unwrap())?;
914 let mut alloc = this.get_ptr_alloc_mut(ptr, size2 * string_length)?.unwrap(); for (offset, wchar) in wide_str.iter().copied().chain(iter::once(0x0000)).enumerate() {
916 let offset = u64::try_from(offset).unwrap();
917 alloc.write_scalar(alloc_range(size2 * offset, size2), Scalar::from_u16(wchar))?;
918 }
919 interp_ok((true, string_length))
920 }
921
922 fn read_wchar_t_str(&self, ptr: Pointer) -> InterpResult<'tcx, Vec<u32>> {
925 let this = self.eval_context_ref();
926 let wchar_t = if this.tcx.sess.target.os == "windows" {
927 this.machine.layouts.u16
929 } else {
930 this.libc_ty_layout("wchar_t")
931 };
932 self.read_c_str_with_char_size(ptr, wchar_t.size, wchar_t.align.abi)
933 }
934
935 fn check_abi<'a>(&self, fn_abi: &FnAbi<'tcx, Ty<'tcx>>, exp_abi: Conv) -> InterpResult<'a, ()> {
937 if fn_abi.conv != exp_abi {
938 throw_ub_format!(
939 "calling a function with ABI {:?} using caller ABI {:?}",
940 exp_abi,
941 fn_abi.conv
942 );
943 }
944 interp_ok(())
945 }
946
947 fn frame_in_std(&self) -> bool {
948 let this = self.eval_context_ref();
949 let frame = this.frame();
950 let instance: Option<_> = try {
952 let scope = frame.current_source_info()?.scope;
953 let inlined_parent = frame.body().source_scopes[scope].inlined_parent_scope?;
954 let source = &frame.body().source_scopes[inlined_parent];
955 source.inlined.expect("inlined_parent_scope points to scope without inline info").0
956 };
957 let instance = instance.unwrap_or(frame.instance());
959 let frame_crate = this.tcx.def_path(instance.def_id()).krate;
964 let crate_name = this.tcx.crate_name(frame_crate);
965 let crate_name = crate_name.as_str();
966 crate_name == "std" || crate_name == "std_miri_test"
968 }
969
970 fn check_abi_and_shim_symbol_clash(
971 &mut self,
972 abi: &FnAbi<'tcx, Ty<'tcx>>,
973 exp_abi: Conv,
974 link_name: Symbol,
975 ) -> InterpResult<'tcx, ()> {
976 self.check_abi(abi, exp_abi)?;
977 if let Some((body, instance)) = self.eval_context_mut().lookup_exported_symbol(link_name)? {
978 if self.eval_context_ref().tcx.is_compiler_builtins(instance.def_id().krate) {
984 return interp_ok(());
985 }
986
987 throw_machine_stop!(TerminationInfo::SymbolShimClashing {
988 link_name,
989 span: body.span.data(),
990 })
991 }
992 interp_ok(())
993 }
994
995 fn check_shim<'a, const N: usize>(
996 &mut self,
997 abi: &FnAbi<'tcx, Ty<'tcx>>,
998 exp_abi: Conv,
999 link_name: Symbol,
1000 args: &'a [OpTy<'tcx>],
1001 ) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]> {
1002 self.check_abi_and_shim_symbol_clash(abi, exp_abi, link_name)?;
1003
1004 if abi.c_variadic {
1005 throw_ub_format!(
1006 "calling a non-variadic function with a variadic caller-side signature"
1007 );
1008 }
1009 if let Ok(ops) = args.try_into() {
1010 return interp_ok(ops);
1011 }
1012 throw_ub_format!(
1013 "incorrect number of arguments for `{link_name}`: got {}, expected {}",
1014 args.len(),
1015 N
1016 )
1017 }
1018
1019 fn check_shim_abi<'a, const N: usize>(
1023 &mut self,
1024 link_name: Symbol,
1025 caller_fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
1026 callee_abi: ExternAbi,
1027 callee_input_tys: [Ty<'tcx>; N],
1028 callee_output_ty: Ty<'tcx>,
1029 caller_args: &'a [OpTy<'tcx>],
1030 ) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]> {
1031 let this = self.eval_context_mut();
1032 let mut inputs_and_output = callee_input_tys.to_vec();
1033 inputs_and_output.push(callee_output_ty);
1034 let fn_sig_binder = Binder::dummy(FnSig {
1035 inputs_and_output: this.machine.tcx.mk_type_list(&inputs_and_output),
1036 c_variadic: false,
1037 safety: Safety::Safe,
1039 abi: callee_abi,
1040 });
1041 let callee_fn_abi = this.fn_abi_of_fn_ptr(fn_sig_binder, Default::default())?;
1042
1043 this.check_abi_and_shim_symbol_clash(caller_fn_abi, callee_fn_abi.conv, link_name)?;
1044
1045 if caller_fn_abi.c_variadic {
1046 throw_ub_format!(
1047 "ABI mismatch: calling a non-variadic function with a variadic caller-side signature"
1048 );
1049 }
1050
1051 if callee_fn_abi.fixed_count != caller_fn_abi.fixed_count {
1052 throw_ub_format!(
1053 "ABI mismatch: expected {} arguments, found {} arguments ",
1054 callee_fn_abi.fixed_count,
1055 caller_fn_abi.fixed_count
1056 );
1057 }
1058
1059 if callee_fn_abi.can_unwind && !caller_fn_abi.can_unwind {
1060 throw_ub_format!(
1061 "ABI mismatch: callee may unwind, but caller-side signature prohibits unwinding",
1062 );
1063 }
1064
1065 if !this.check_argument_compat(&caller_fn_abi.ret, &callee_fn_abi.ret)? {
1066 throw_ub!(AbiMismatchReturn {
1067 caller_ty: caller_fn_abi.ret.layout.ty,
1068 callee_ty: callee_fn_abi.ret.layout.ty
1069 });
1070 }
1071
1072 if let Some(index) = caller_fn_abi
1073 .args
1074 .iter()
1075 .zip(callee_fn_abi.args.iter())
1076 .map(|(caller_arg, callee_arg)| this.check_argument_compat(caller_arg, callee_arg))
1077 .collect::<InterpResult<'tcx, Vec<bool>>>()?
1078 .into_iter()
1079 .position(|b| !b)
1080 {
1081 throw_ub!(AbiMismatchArgument {
1082 caller_ty: caller_fn_abi.args[index].layout.ty,
1083 callee_ty: callee_fn_abi.args[index].layout.ty
1084 });
1085 }
1086
1087 if let Ok(ops) = caller_args.try_into() {
1088 return interp_ok(ops);
1089 }
1090 unreachable!()
1091 }
1092
1093 fn check_shim_variadic<'a, const N: usize>(
1096 &mut self,
1097 abi: &FnAbi<'tcx, Ty<'tcx>>,
1098 exp_abi: Conv,
1099 link_name: Symbol,
1100 args: &'a [OpTy<'tcx>],
1101 ) -> InterpResult<'tcx, (&'a [OpTy<'tcx>; N], &'a [OpTy<'tcx>])>
1102 where
1103 &'a [OpTy<'tcx>; N]: TryFrom<&'a [OpTy<'tcx>]>,
1104 {
1105 self.check_abi_and_shim_symbol_clash(abi, exp_abi, link_name)?;
1106
1107 if !abi.c_variadic {
1108 throw_ub_format!(
1109 "calling a variadic function with a non-variadic caller-side signature"
1110 );
1111 }
1112 if abi.fixed_count != u32::try_from(N).unwrap() {
1113 throw_ub_format!(
1114 "incorrect number of fixed arguments for variadic function `{}`: got {}, expected {N}",
1115 link_name.as_str(),
1116 abi.fixed_count
1117 )
1118 }
1119 if let Some(args) = args.split_first_chunk() {
1120 return interp_ok(args);
1121 }
1122 panic!("mismatch between signature and `args` slice");
1123 }
1124
1125 fn mark_immutable(&mut self, mplace: &MPlaceTy<'tcx>) {
1127 let this = self.eval_context_mut();
1128 let provenance = mplace.ptr().into_pointer_or_addr().unwrap().provenance;
1130 this.alloc_mark_immutable(provenance.get_alloc_id().unwrap()).unwrap();
1131 }
1132
1133 fn float_to_int_checked(
1137 &self,
1138 src: &ImmTy<'tcx>,
1139 cast_to: TyAndLayout<'tcx>,
1140 round: rustc_apfloat::Round,
1141 ) -> InterpResult<'tcx, Option<ImmTy<'tcx>>> {
1142 let this = self.eval_context_ref();
1143
1144 fn float_to_int_inner<'tcx, F: rustc_apfloat::Float>(
1145 ecx: &MiriInterpCx<'tcx>,
1146 src: F,
1147 cast_to: TyAndLayout<'tcx>,
1148 round: rustc_apfloat::Round,
1149 ) -> (Scalar, rustc_apfloat::Status) {
1150 let int_size = cast_to.layout.size;
1151 match cast_to.ty.kind() {
1152 ty::Uint(_) => {
1154 let res = src.to_u128_r(int_size.bits_usize(), round, &mut false);
1155 (Scalar::from_uint(res.value, int_size), res.status)
1156 }
1157 ty::Int(_) => {
1159 let res = src.to_i128_r(int_size.bits_usize(), round, &mut false);
1160 (Scalar::from_int(res.value, int_size), res.status)
1161 }
1162 _ =>
1164 span_bug!(
1165 ecx.cur_span(),
1166 "attempted float-to-int conversion with non-int output type {}",
1167 cast_to.ty,
1168 ),
1169 }
1170 }
1171
1172 let ty::Float(fty) = src.layout.ty.kind() else {
1173 bug!("float_to_int_checked: non-float input type {}", src.layout.ty)
1174 };
1175
1176 let (val, status) = match fty {
1177 FloatTy::F16 =>
1178 float_to_int_inner::<Half>(this, src.to_scalar().to_f16()?, cast_to, round),
1179 FloatTy::F32 =>
1180 float_to_int_inner::<Single>(this, src.to_scalar().to_f32()?, cast_to, round),
1181 FloatTy::F64 =>
1182 float_to_int_inner::<Double>(this, src.to_scalar().to_f64()?, cast_to, round),
1183 FloatTy::F128 =>
1184 float_to_int_inner::<Quad>(this, src.to_scalar().to_f128()?, cast_to, round),
1185 };
1186
1187 if status.intersects(
1188 rustc_apfloat::Status::INVALID_OP
1189 | rustc_apfloat::Status::OVERFLOW
1190 | rustc_apfloat::Status::UNDERFLOW,
1191 ) {
1192 interp_ok(None)
1195 } else {
1196 interp_ok(Some(ImmTy::from_scalar(val, cast_to)))
1199 }
1200 }
1201
1202 fn get_twice_wide_int_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
1204 let this = self.eval_context_ref();
1205 match ty.kind() {
1206 ty::Uint(UintTy::U8) => this.tcx.types.u16,
1208 ty::Uint(UintTy::U16) => this.tcx.types.u32,
1209 ty::Uint(UintTy::U32) => this.tcx.types.u64,
1210 ty::Uint(UintTy::U64) => this.tcx.types.u128,
1211 ty::Int(IntTy::I8) => this.tcx.types.i16,
1213 ty::Int(IntTy::I16) => this.tcx.types.i32,
1214 ty::Int(IntTy::I32) => this.tcx.types.i64,
1215 ty::Int(IntTy::I64) => this.tcx.types.i128,
1216 _ => span_bug!(this.cur_span(), "unexpected type: {ty:?}"),
1217 }
1218 }
1219
1220 fn expect_target_feature_for_intrinsic(
1225 &self,
1226 intrinsic: Symbol,
1227 target_feature: &str,
1228 ) -> InterpResult<'tcx, ()> {
1229 let this = self.eval_context_ref();
1230 if !this.tcx.sess.unstable_target_features.contains(&Symbol::intern(target_feature)) {
1231 throw_ub_format!(
1232 "attempted to call intrinsic `{intrinsic}` that requires missing target feature {target_feature}"
1233 );
1234 }
1235 interp_ok(())
1236 }
1237
1238 fn lookup_link_section(&mut self, name: &str) -> InterpResult<'tcx, Vec<ImmTy<'tcx>>> {
1240 let this = self.eval_context_mut();
1241 let tcx = this.tcx.tcx;
1242
1243 let mut array = vec![];
1244
1245 iter_exported_symbols(tcx, |_cnum, def_id| {
1246 let attrs = tcx.codegen_fn_attrs(def_id);
1247 let Some(link_section) = attrs.link_section else {
1248 return interp_ok(());
1249 };
1250 if link_section.as_str() == name {
1251 let instance = ty::Instance::mono(tcx, def_id);
1252 let const_val = this.eval_global(instance).unwrap_or_else(|err| {
1253 panic!(
1254 "failed to evaluate static in required link_section: {def_id:?}\n{err:?}"
1255 )
1256 });
1257 let val = this.read_immediate(&const_val)?;
1258 array.push(val);
1259 }
1260 interp_ok(())
1261 })?;
1262
1263 interp_ok(array)
1264 }
1265
1266 fn mangle_internal_symbol<'a>(&'a mut self, name: &'static str) -> &'a str
1267 where
1268 'tcx: 'a,
1269 {
1270 let this = self.eval_context_mut();
1271 let tcx = *this.tcx;
1272 this.machine
1273 .mangle_internal_symbol_cache
1274 .entry(name)
1275 .or_insert_with(|| mangle_internal_symbol(tcx, name))
1276 }
1277}
1278
1279impl<'tcx> MiriMachine<'tcx> {
1280 pub fn current_span(&self) -> Span {
1285 self.threads.active_thread_ref().current_span()
1286 }
1287
1288 pub fn caller_span(&self) -> Span {
1294 let frame_idx = self.top_user_relevant_frame().unwrap();
1297 let frame_idx = cmp::min(frame_idx, self.stack().len().saturating_sub(2));
1298 self.stack()[frame_idx].current_span()
1299 }
1300
1301 fn stack(&self) -> &[Frame<'tcx, Provenance, machine::FrameExtra<'tcx>>] {
1302 self.threads.active_thread_stack()
1303 }
1304
1305 fn top_user_relevant_frame(&self) -> Option<usize> {
1306 self.threads.active_thread_ref().top_user_relevant_frame()
1307 }
1308
1309 pub fn is_user_relevant(&self, frame: &Frame<'tcx, Provenance>) -> bool {
1311 let def_id = frame.instance().def_id();
1312 (def_id.is_local() || self.local_crates.contains(&def_id.krate))
1313 && !frame.instance().def.requires_caller_location(self.tcx)
1314 }
1315}
1316
1317pub fn check_intrinsic_arg_count<'a, 'tcx, const N: usize>(
1319 args: &'a [OpTy<'tcx>],
1320) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]>
1321where
1322 &'a [OpTy<'tcx>; N]: TryFrom<&'a [OpTy<'tcx>]>,
1323{
1324 if let Ok(ops) = args.try_into() {
1325 return interp_ok(ops);
1326 }
1327 throw_ub_format!(
1328 "incorrect number of arguments for intrinsic: got {}, expected {}",
1329 args.len(),
1330 N
1331 )
1332}
1333
1334pub fn check_min_vararg_count<'a, 'tcx, const N: usize>(
1338 name: &'a str,
1339 args: &'a [OpTy<'tcx>],
1340) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]> {
1341 if let Some((ops, _)) = args.split_first_chunk() {
1342 return interp_ok(ops);
1343 }
1344 throw_ub_format!(
1345 "not enough variadic arguments for `{name}`: got {}, expected at least {}",
1346 args.len(),
1347 N
1348 )
1349}
1350
1351pub fn isolation_abort_error<'tcx>(name: &str) -> InterpResult<'tcx> {
1352 throw_machine_stop!(TerminationInfo::UnsupportedInIsolation(format!(
1353 "{name} not available when isolation is enabled",
1354 )))
1355}
1356
1357pub fn get_local_crates(tcx: TyCtxt<'_>) -> Vec<CrateNum> {
1360 let local_crate_names = std::env::var("MIRI_LOCAL_CRATES")
1363 .map(|crates| crates.split(',').map(|krate| krate.to_string()).collect::<Vec<_>>())
1364 .unwrap_or_default();
1365 let mut local_crates = Vec::new();
1366 for &crate_num in tcx.crates(()) {
1367 let name = tcx.crate_name(crate_num);
1368 let name = name.as_str();
1369 if local_crate_names.iter().any(|local_name| local_name == name) {
1370 local_crates.push(crate_num);
1371 }
1372 }
1373 local_crates
1374}
1375
1376pub(crate) fn bool_to_simd_element(b: bool, size: Size) -> Scalar {
1377 let val = if b { -1 } else { 0 };
1381 Scalar::from_int(val, size)
1382}
1383
1384pub(crate) fn simd_element_to_bool(elem: ImmTy<'_>) -> InterpResult<'_, bool> {
1385 assert!(
1386 matches!(elem.layout.ty.kind(), ty::Int(_) | ty::Uint(_)),
1387 "SIMD mask element type must be an integer, but this is `{}`",
1388 elem.layout.ty
1389 );
1390 let val = elem.to_scalar().to_int(elem.layout.size)?;
1391 interp_ok(match val {
1392 0 => false,
1393 -1 => true,
1394 _ => throw_ub_format!("each element of a SIMD mask must be all-0-bits or all-1-bits"),
1395 })
1396}
1397
1398pub(crate) fn windows_check_buffer_size((success, len): (bool, u64)) -> u32 {
1402 if success {
1403 u32::try_from(len.strict_sub(1)).unwrap()
1406 } else {
1407 u32::try_from(len).unwrap()
1410 }
1411}