| //! An interpreter for MIR used in CTFE and by miri. |
| |
| #[macro_export] |
| macro_rules! err_unsup { |
| ($($tt:tt)*) => { |
| $crate::mir::interpret::InterpError::Unsupported( |
| $crate::mir::interpret::UnsupportedOpInfo::$($tt)* |
| ) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_unsup_format { |
| ($($tt:tt)*) => { err_unsup!(Unsupported(format!($($tt)*))) }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_inval { |
| ($($tt:tt)*) => { |
| $crate::mir::interpret::InterpError::InvalidProgram( |
| $crate::mir::interpret::InvalidProgramInfo::$($tt)* |
| ) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_ub { |
| ($($tt:tt)*) => { |
| $crate::mir::interpret::InterpError::UndefinedBehavior( |
| $crate::mir::interpret::UndefinedBehaviorInfo::$($tt)* |
| ) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_ub_format { |
| ($($tt:tt)*) => { err_ub!(Ub(format!($($tt)*))) }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_exhaust { |
| ($($tt:tt)*) => { |
| $crate::mir::interpret::InterpError::ResourceExhaustion( |
| $crate::mir::interpret::ResourceExhaustionInfo::$($tt)* |
| ) |
| }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_machine_stop { |
| ($($tt:tt)*) => { |
| $crate::mir::interpret::InterpError::MachineStop(Box::new($($tt)*)) |
| }; |
| } |
| |
| // In the `throw_*` macros, avoid `return` to make them work with `try {}`. |
| #[macro_export] |
| macro_rules! throw_unsup { |
| ($($tt:tt)*) => { do yeet err_unsup!($($tt)*) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_unsup_format { |
| ($($tt:tt)*) => { throw_unsup!(Unsupported(format!($($tt)*))) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_inval { |
| ($($tt:tt)*) => { do yeet err_inval!($($tt)*) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_ub { |
| ($($tt:tt)*) => { do yeet err_ub!($($tt)*) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_ub_format { |
| ($($tt:tt)*) => { throw_ub!(Ub(format!($($tt)*))) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_exhaust { |
| ($($tt:tt)*) => { do yeet err_exhaust!($($tt)*) }; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_machine_stop { |
| ($($tt:tt)*) => { do yeet err_machine_stop!($($tt)*) }; |
| } |
| |
| #[macro_export] |
| macro_rules! err_ub_custom { |
| ($msg:expr $(, $($name:ident = $value:expr),* $(,)?)?) => {{ |
| $( |
| let ($($name,)*) = ($($value,)*); |
| )? |
| err_ub!(Custom( |
| rustc_middle::error::CustomSubdiagnostic { |
| msg: || $msg, |
| add_args: Box::new(move |mut set_arg| { |
| $($( |
| set_arg(stringify!($name).into(), rustc_errors::IntoDiagArg::into_diag_arg($name)); |
| )*)? |
| }) |
| } |
| )) |
| }}; |
| } |
| |
| #[macro_export] |
| macro_rules! throw_ub_custom { |
| ($($tt:tt)*) => { do yeet err_ub_custom!($($tt)*) }; |
| } |
| |
| mod allocation; |
| mod error; |
| mod pointer; |
| mod queries; |
| mod value; |
| |
| use std::fmt; |
| use std::io; |
| use std::io::{Read, Write}; |
| use std::num::NonZero; |
| use std::sync::atomic::{AtomicU32, Ordering}; |
| |
| use smallvec::{smallvec, SmallVec}; |
| |
| use rustc_ast::LitKind; |
| use rustc_data_structures::fx::FxHashMap; |
| use rustc_data_structures::sync::{HashMapExt, Lock}; |
| use rustc_errors::ErrorGuaranteed; |
| use rustc_hir::def_id::{DefId, LocalDefId}; |
| use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable}; |
| use rustc_middle::ty::print::with_no_trimmed_paths; |
| use rustc_serialize::{Decodable, Encodable}; |
| use rustc_target::abi::{AddressSpace, Endian, HasDataLayout}; |
| |
| use crate::mir; |
| use crate::ty::codec::{TyDecoder, TyEncoder}; |
| use crate::ty::GenericArgKind; |
| use crate::ty::{self, Instance, Ty, TyCtxt}; |
| |
| pub use self::error::{ |
| BadBytesAccess, CheckAlignMsg, CheckInAllocMsg, ErrorHandled, EvalStaticInitializerRawResult, |
| EvalToAllocationRawResult, EvalToConstValueResult, EvalToValTreeResult, ExpectedKind, |
| InterpError, InterpErrorInfo, InterpResult, InvalidMetaKind, InvalidProgramInfo, |
| MachineStopType, Misalignment, PointerKind, ReportedErrorInfo, ResourceExhaustionInfo, |
| ScalarSizeMismatch, UndefinedBehaviorInfo, UnsupportedOpInfo, ValidationErrorInfo, |
| ValidationErrorKind, |
| }; |
| |
| pub use self::value::Scalar; |
| |
| pub use self::allocation::{ |
| alloc_range, AllocBytes, AllocError, AllocRange, AllocResult, Allocation, ConstAllocation, |
| InitChunk, InitChunkIter, |
| }; |
| |
| pub use self::pointer::{CtfeProvenance, Pointer, PointerArithmetic, Provenance}; |
| |
| /// Uniquely identifies one of the following: |
| /// - A constant |
| /// - A static |
| #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, TyEncodable, TyDecodable)] |
| #[derive(HashStable, TypeFoldable, TypeVisitable)] |
| pub struct GlobalId<'tcx> { |
| /// For a constant or static, the `Instance` of the item itself. |
| /// For a promoted global, the `Instance` of the function they belong to. |
| pub instance: ty::Instance<'tcx>, |
| |
| /// The index for promoted globals within their function's `mir::Body`. |
| pub promoted: Option<mir::Promoted>, |
| } |
| |
| impl<'tcx> GlobalId<'tcx> { |
| pub fn display(self, tcx: TyCtxt<'tcx>) -> String { |
| let instance_name = with_no_trimmed_paths!(tcx.def_path_str(self.instance.def.def_id())); |
| if let Some(promoted) = self.promoted { |
| format!("{instance_name}::{promoted:?}") |
| } else { |
| instance_name |
| } |
| } |
| } |
| |
| /// Input argument for `tcx.lit_to_const`. |
| #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, HashStable)] |
| pub struct LitToConstInput<'tcx> { |
| /// The absolute value of the resultant constant. |
| pub lit: &'tcx LitKind, |
| /// The type of the constant. |
| pub ty: Ty<'tcx>, |
| /// If the constant is negative. |
| pub neg: bool, |
| } |
| |
| /// Error type for `tcx.lit_to_const`. |
| #[derive(Copy, Clone, Debug, Eq, PartialEq, HashStable)] |
| pub enum LitToConstError { |
| /// The literal's inferred type did not match the expected `ty` in the input. |
| /// This is used for graceful error handling (`span_delayed_bug`) in |
| /// type checking (`Const::from_anon_const`). |
| TypeError, |
| Reported(ErrorGuaranteed), |
| } |
| |
| #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)] |
| pub struct AllocId(pub NonZero<u64>); |
| |
| // We want the `Debug` output to be readable as it is used by `derive(Debug)` for |
| // all the Miri types. |
| impl fmt::Debug for AllocId { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| if f.alternate() { write!(f, "a{}", self.0) } else { write!(f, "alloc{}", self.0) } |
| } |
| } |
| |
| // No "Display" since AllocIds are not usually user-visible. |
| |
| #[derive(TyDecodable, TyEncodable)] |
| enum AllocDiscriminant { |
| Alloc, |
| Fn, |
| VTable, |
| Static, |
| } |
| |
| pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>>( |
| encoder: &mut E, |
| tcx: TyCtxt<'tcx>, |
| alloc_id: AllocId, |
| ) { |
| match tcx.global_alloc(alloc_id) { |
| GlobalAlloc::Memory(alloc) => { |
| trace!("encoding {:?} with {:#?}", alloc_id, alloc); |
| AllocDiscriminant::Alloc.encode(encoder); |
| alloc.encode(encoder); |
| } |
| GlobalAlloc::Function(fn_instance) => { |
| trace!("encoding {:?} with {:#?}", alloc_id, fn_instance); |
| AllocDiscriminant::Fn.encode(encoder); |
| fn_instance.encode(encoder); |
| } |
| GlobalAlloc::VTable(ty, poly_trait_ref) => { |
| trace!("encoding {:?} with {ty:#?}, {poly_trait_ref:#?}", alloc_id); |
| AllocDiscriminant::VTable.encode(encoder); |
| ty.encode(encoder); |
| poly_trait_ref.encode(encoder); |
| } |
| GlobalAlloc::Static(did) => { |
| assert!(!tcx.is_thread_local_static(did)); |
| // References to statics doesn't need to know about their allocations, |
| // just about its `DefId`. |
| AllocDiscriminant::Static.encode(encoder); |
| // Cannot use `did.encode(encoder)` because of a bug around |
| // specializations and method calls. |
| Encodable::<E>::encode(&did, encoder); |
| } |
| } |
| } |
| |
| // Used to avoid infinite recursion when decoding cyclic allocations. |
| type DecodingSessionId = NonZero<u32>; |
| |
| #[derive(Clone)] |
| enum State { |
| Empty, |
| InProgressNonAlloc(SmallVec<[DecodingSessionId; 1]>), |
| InProgress(SmallVec<[DecodingSessionId; 1]>, AllocId), |
| Done(AllocId), |
| } |
| |
| pub struct AllocDecodingState { |
| // For each `AllocId`, we keep track of which decoding state it's currently in. |
| decoding_state: Vec<Lock<State>>, |
| // The offsets of each allocation in the data stream. |
| data_offsets: Vec<u64>, |
| } |
| |
| impl AllocDecodingState { |
| #[inline] |
| pub fn new_decoding_session(&self) -> AllocDecodingSession<'_> { |
| static DECODER_SESSION_ID: AtomicU32 = AtomicU32::new(0); |
| let counter = DECODER_SESSION_ID.fetch_add(1, Ordering::SeqCst); |
| |
| // Make sure this is never zero. |
| let session_id = DecodingSessionId::new((counter & 0x7FFFFFFF) + 1).unwrap(); |
| |
| AllocDecodingSession { state: self, session_id } |
| } |
| |
| pub fn new(data_offsets: Vec<u64>) -> Self { |
| let decoding_state = |
| std::iter::repeat_with(|| Lock::new(State::Empty)).take(data_offsets.len()).collect(); |
| |
| Self { decoding_state, data_offsets } |
| } |
| } |
| |
| #[derive(Copy, Clone)] |
| pub struct AllocDecodingSession<'s> { |
| state: &'s AllocDecodingState, |
| session_id: DecodingSessionId, |
| } |
| |
| impl<'s> AllocDecodingSession<'s> { |
| /// Decodes an `AllocId` in a thread-safe way. |
| pub fn decode_alloc_id<'tcx, D>(&self, decoder: &mut D) -> AllocId |
| where |
| D: TyDecoder<I = TyCtxt<'tcx>>, |
| { |
| // Read the index of the allocation. |
| let idx = usize::try_from(decoder.read_u32()).unwrap(); |
| let pos = usize::try_from(self.state.data_offsets[idx]).unwrap(); |
| |
| // Decode the `AllocDiscriminant` now so that we know if we have to reserve an |
| // `AllocId`. |
| let (alloc_kind, pos) = decoder.with_position(pos, |decoder| { |
| let alloc_kind = AllocDiscriminant::decode(decoder); |
| (alloc_kind, decoder.position()) |
| }); |
| |
| // Check the decoding state to see if it's already decoded or if we should |
| // decode it here. |
| let alloc_id = { |
| let mut entry = self.state.decoding_state[idx].lock(); |
| |
| match *entry { |
| State::Done(alloc_id) => { |
| return alloc_id; |
| } |
| ref mut entry @ State::Empty => { |
| // We are allowed to decode. |
| match alloc_kind { |
| AllocDiscriminant::Alloc => { |
| // If this is an allocation, we need to reserve an |
| // `AllocId` so we can decode cyclic graphs. |
| let alloc_id = decoder.interner().reserve_alloc_id(); |
| *entry = State::InProgress(smallvec![self.session_id], alloc_id); |
| Some(alloc_id) |
| } |
| AllocDiscriminant::Fn |
| | AllocDiscriminant::Static |
| | AllocDiscriminant::VTable => { |
| // Fns and statics cannot be cyclic, and their `AllocId` |
| // is determined later by interning. |
| *entry = State::InProgressNonAlloc(smallvec![self.session_id]); |
| None |
| } |
| } |
| } |
| State::InProgressNonAlloc(ref mut sessions) => { |
| if sessions.contains(&self.session_id) { |
| bug!("this should be unreachable"); |
| } else { |
| // Start decoding concurrently. |
| sessions.push(self.session_id); |
| None |
| } |
| } |
| State::InProgress(ref mut sessions, alloc_id) => { |
| if sessions.contains(&self.session_id) { |
| // Don't recurse. |
| return alloc_id; |
| } else { |
| // Start decoding concurrently. |
| sessions.push(self.session_id); |
| Some(alloc_id) |
| } |
| } |
| } |
| }; |
| |
| // Now decode the actual data. |
| let alloc_id = decoder.with_position(pos, |decoder| { |
| match alloc_kind { |
| AllocDiscriminant::Alloc => { |
| let alloc = <ConstAllocation<'tcx> as Decodable<_>>::decode(decoder); |
| // We already have a reserved `AllocId`. |
| let alloc_id = alloc_id.unwrap(); |
| trace!("decoded alloc {:?}: {:#?}", alloc_id, alloc); |
| decoder.interner().set_alloc_id_same_memory(alloc_id, alloc); |
| alloc_id |
| } |
| AllocDiscriminant::Fn => { |
| assert!(alloc_id.is_none()); |
| trace!("creating fn alloc ID"); |
| let instance = ty::Instance::decode(decoder); |
| trace!("decoded fn alloc instance: {:?}", instance); |
| let alloc_id = decoder.interner().reserve_and_set_fn_alloc(instance); |
| alloc_id |
| } |
| AllocDiscriminant::VTable => { |
| assert!(alloc_id.is_none()); |
| trace!("creating vtable alloc ID"); |
| let ty = <Ty<'_> as Decodable<D>>::decode(decoder); |
| let poly_trait_ref = |
| <Option<ty::PolyExistentialTraitRef<'_>> as Decodable<D>>::decode(decoder); |
| trace!("decoded vtable alloc instance: {ty:?}, {poly_trait_ref:?}"); |
| let alloc_id = |
| decoder.interner().reserve_and_set_vtable_alloc(ty, poly_trait_ref); |
| alloc_id |
| } |
| AllocDiscriminant::Static => { |
| assert!(alloc_id.is_none()); |
| trace!("creating extern static alloc ID"); |
| let did = <DefId as Decodable<D>>::decode(decoder); |
| trace!("decoded static def-ID: {:?}", did); |
| let alloc_id = decoder.interner().reserve_and_set_static_alloc(did); |
| alloc_id |
| } |
| } |
| }); |
| |
| self.state.decoding_state[idx].with_lock(|entry| { |
| *entry = State::Done(alloc_id); |
| }); |
| |
| alloc_id |
| } |
| } |
| |
| /// An allocation in the global (tcx-managed) memory can be either a function pointer, |
| /// a static, or a "real" allocation with some data in it. |
| #[derive(Debug, Clone, Eq, PartialEq, Hash, TyDecodable, TyEncodable, HashStable)] |
| pub enum GlobalAlloc<'tcx> { |
| /// The alloc ID is used as a function pointer. |
| Function(Instance<'tcx>), |
| /// This alloc ID points to a symbolic (not-reified) vtable. |
| VTable(Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>), |
| /// The alloc ID points to a "lazy" static variable that did not get computed (yet). |
| /// This is also used to break the cycle in recursive statics. |
| Static(DefId), |
| /// The alloc ID points to memory. |
| Memory(ConstAllocation<'tcx>), |
| } |
| |
| impl<'tcx> GlobalAlloc<'tcx> { |
| /// Panics if the `GlobalAlloc` does not refer to an `GlobalAlloc::Memory` |
| #[track_caller] |
| #[inline] |
| pub fn unwrap_memory(&self) -> ConstAllocation<'tcx> { |
| match *self { |
| GlobalAlloc::Memory(mem) => mem, |
| _ => bug!("expected memory, got {:?}", self), |
| } |
| } |
| |
| /// Panics if the `GlobalAlloc` is not `GlobalAlloc::Function` |
| #[track_caller] |
| #[inline] |
| pub fn unwrap_fn(&self) -> Instance<'tcx> { |
| match *self { |
| GlobalAlloc::Function(instance) => instance, |
| _ => bug!("expected function, got {:?}", self), |
| } |
| } |
| |
| /// Panics if the `GlobalAlloc` is not `GlobalAlloc::VTable` |
| #[track_caller] |
| #[inline] |
| pub fn unwrap_vtable(&self) -> (Ty<'tcx>, Option<ty::PolyExistentialTraitRef<'tcx>>) { |
| match *self { |
| GlobalAlloc::VTable(ty, poly_trait_ref) => (ty, poly_trait_ref), |
| _ => bug!("expected vtable, got {:?}", self), |
| } |
| } |
| |
| /// The address space that this `GlobalAlloc` should be placed in. |
| #[inline] |
| pub fn address_space(&self, cx: &impl HasDataLayout) -> AddressSpace { |
| match self { |
| GlobalAlloc::Function(..) => cx.data_layout().instruction_address_space, |
| GlobalAlloc::Static(..) | GlobalAlloc::Memory(..) | GlobalAlloc::VTable(..) => { |
| AddressSpace::DATA |
| } |
| } |
| } |
| } |
| |
| pub(crate) struct AllocMap<'tcx> { |
| /// Maps `AllocId`s to their corresponding allocations. |
| alloc_map: FxHashMap<AllocId, GlobalAlloc<'tcx>>, |
| |
| /// Used to ensure that statics and functions only get one associated `AllocId`. |
| /// Should never contain a `GlobalAlloc::Memory`! |
| // |
| // FIXME: Should we just have two separate dedup maps for statics and functions each? |
| dedup: FxHashMap<GlobalAlloc<'tcx>, AllocId>, |
| |
| /// The `AllocId` to assign to the next requested ID. |
| /// Always incremented; never gets smaller. |
| next_id: AllocId, |
| } |
| |
| impl<'tcx> AllocMap<'tcx> { |
| pub(crate) fn new() -> Self { |
| AllocMap { |
| alloc_map: Default::default(), |
| dedup: Default::default(), |
| next_id: AllocId(NonZero::new(1).unwrap()), |
| } |
| } |
| fn reserve(&mut self) -> AllocId { |
| let next = self.next_id; |
| self.next_id.0 = self.next_id.0.checked_add(1).expect( |
| "You overflowed a u64 by incrementing by 1... \ |
| You've just earned yourself a free drink if we ever meet. \ |
| Seriously, how did you do that?!", |
| ); |
| next |
| } |
| } |
| |
| impl<'tcx> TyCtxt<'tcx> { |
| /// Obtains a new allocation ID that can be referenced but does not |
| /// yet have an allocation backing it. |
| /// |
| /// Make sure to call `set_alloc_id_memory` or `set_alloc_id_same_memory` before returning such |
| /// an `AllocId` from a query. |
| pub fn reserve_alloc_id(self) -> AllocId { |
| self.alloc_map.lock().reserve() |
| } |
| |
| /// Reserves a new ID *if* this allocation has not been dedup-reserved before. |
| /// Should only be used for "symbolic" allocations (function pointers, vtables, statics), we |
| /// don't want to dedup IDs for "real" memory! |
| fn reserve_and_set_dedup(self, alloc: GlobalAlloc<'tcx>) -> AllocId { |
| let mut alloc_map = self.alloc_map.lock(); |
| match alloc { |
| GlobalAlloc::Function(..) | GlobalAlloc::Static(..) | GlobalAlloc::VTable(..) => {} |
| GlobalAlloc::Memory(..) => bug!("Trying to dedup-reserve memory with real data!"), |
| } |
| if let Some(&alloc_id) = alloc_map.dedup.get(&alloc) { |
| return alloc_id; |
| } |
| let id = alloc_map.reserve(); |
| debug!("creating alloc {alloc:?} with id {id:?}"); |
| alloc_map.alloc_map.insert(id, alloc.clone()); |
| alloc_map.dedup.insert(alloc, id); |
| id |
| } |
| |
| /// Generates an `AllocId` for a static or return a cached one in case this function has been |
| /// called on the same static before. |
| pub fn reserve_and_set_static_alloc(self, static_id: DefId) -> AllocId { |
| self.reserve_and_set_dedup(GlobalAlloc::Static(static_id)) |
| } |
| |
| /// Generates an `AllocId` for a function. Depending on the function type, |
| /// this might get deduplicated or assigned a new ID each time. |
| pub fn reserve_and_set_fn_alloc(self, instance: Instance<'tcx>) -> AllocId { |
| // Functions cannot be identified by pointers, as asm-equal functions can get deduplicated |
| // by the linker (we set the "unnamed_addr" attribute for LLVM) and functions can be |
| // duplicated across crates. |
| // We thus generate a new `AllocId` for every mention of a function. This means that |
| // `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true. |
| // However, formatting code relies on function identity (see #58320), so we only do |
| // this for generic functions. Lifetime parameters are ignored. |
| let is_generic = instance |
| .args |
| .into_iter() |
| .any(|kind| !matches!(kind.unpack(), GenericArgKind::Lifetime(_))); |
| if is_generic { |
| // Get a fresh ID. |
| let mut alloc_map = self.alloc_map.lock(); |
| let id = alloc_map.reserve(); |
| alloc_map.alloc_map.insert(id, GlobalAlloc::Function(instance)); |
| id |
| } else { |
| // Deduplicate. |
| self.reserve_and_set_dedup(GlobalAlloc::Function(instance)) |
| } |
| } |
| |
| /// Generates an `AllocId` for a (symbolic, not-reified) vtable. Will get deduplicated. |
| pub fn reserve_and_set_vtable_alloc( |
| self, |
| ty: Ty<'tcx>, |
| poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>, |
| ) -> AllocId { |
| self.reserve_and_set_dedup(GlobalAlloc::VTable(ty, poly_trait_ref)) |
| } |
| |
| /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical |
| /// `Allocation` with a different `AllocId`. |
| /// Statics with identical content will still point to the same `Allocation`, i.e., |
| /// their data will be deduplicated through `Allocation` interning -- but they |
| /// are different places in memory and as such need different IDs. |
| pub fn reserve_and_set_memory_alloc(self, mem: ConstAllocation<'tcx>) -> AllocId { |
| let id = self.reserve_alloc_id(); |
| self.set_alloc_id_memory(id, mem); |
| id |
| } |
| |
| /// Returns `None` in case the `AllocId` is dangling. An `InterpretCx` can still have a |
| /// local `Allocation` for that `AllocId`, but having such an `AllocId` in a constant is |
| /// illegal and will likely ICE. |
| /// This function exists to allow const eval to detect the difference between evaluation- |
| /// local dangling pointers and allocations in constants/statics. |
| #[inline] |
| pub fn try_get_global_alloc(self, id: AllocId) -> Option<GlobalAlloc<'tcx>> { |
| self.alloc_map.lock().alloc_map.get(&id).cloned() |
| } |
| |
| #[inline] |
| #[track_caller] |
| /// Panics in case the `AllocId` is dangling. Since that is impossible for `AllocId`s in |
| /// constants (as all constants must pass interning and validation that check for dangling |
| /// ids), this function is frequently used throughout rustc, but should not be used within |
| /// the interpreter. |
| pub fn global_alloc(self, id: AllocId) -> GlobalAlloc<'tcx> { |
| match self.try_get_global_alloc(id) { |
| Some(alloc) => alloc, |
| None => bug!("could not find allocation for {id:?}"), |
| } |
| } |
| |
| /// Freezes an `AllocId` created with `reserve` by pointing it at an `Allocation`. Trying to |
| /// call this function twice, even with the same `Allocation` will ICE the compiler. |
| pub fn set_alloc_id_memory(self, id: AllocId, mem: ConstAllocation<'tcx>) { |
| if let Some(old) = self.alloc_map.lock().alloc_map.insert(id, GlobalAlloc::Memory(mem)) { |
| bug!("tried to set allocation ID {id:?}, but it was already existing as {old:#?}"); |
| } |
| } |
| |
| /// Freezes an `AllocId` created with `reserve` by pointing it at a static item. Trying to |
| /// call this function twice, even with the same `DefId` will ICE the compiler. |
| pub fn set_nested_alloc_id_static(self, id: AllocId, def_id: LocalDefId) { |
| if let Some(old) = |
| self.alloc_map.lock().alloc_map.insert(id, GlobalAlloc::Static(def_id.to_def_id())) |
| { |
| bug!("tried to set allocation ID {id:?}, but it was already existing as {old:#?}"); |
| } |
| } |
| |
| /// Freezes an `AllocId` created with `reserve` by pointing it at an `Allocation`. May be called |
| /// twice for the same `(AllocId, Allocation)` pair. |
| fn set_alloc_id_same_memory(self, id: AllocId, mem: ConstAllocation<'tcx>) { |
| self.alloc_map.lock().alloc_map.insert_same(id, GlobalAlloc::Memory(mem)); |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Methods to access integers in the target endianness |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| #[inline] |
| pub fn write_target_uint( |
| endianness: Endian, |
| mut target: &mut [u8], |
| data: u128, |
| ) -> Result<(), io::Error> { |
| // This u128 holds an "any-size uint" (since smaller uints can fits in it) |
| // So we do not write all bytes of the u128, just the "payload". |
| match endianness { |
| Endian::Little => target.write(&data.to_le_bytes())?, |
| Endian::Big => target.write(&data.to_be_bytes()[16 - target.len()..])?, |
| }; |
| debug_assert!(target.len() == 0); // We should have filled the target buffer. |
| Ok(()) |
| } |
| |
| #[inline] |
| pub fn read_target_uint(endianness: Endian, mut source: &[u8]) -> Result<u128, io::Error> { |
| // This u128 holds an "any-size uint" (since smaller uints can fits in it) |
| let mut buf = [0u8; std::mem::size_of::<u128>()]; |
| // So we do not read exactly 16 bytes into the u128, just the "payload". |
| let uint = match endianness { |
| Endian::Little => { |
| source.read_exact(&mut buf[..source.len()])?; |
| Ok(u128::from_le_bytes(buf)) |
| } |
| Endian::Big => { |
| source.read_exact(&mut buf[16 - source.len()..])?; |
| Ok(u128::from_be_bytes(buf)) |
| } |
| }; |
| debug_assert!(source.len() == 0); // We should have consumed the source buffer. |
| uint |
| } |
