use rustc_ast::ast::Mutability;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::DefId;
use rustc_middle::ty::{self, Instance, ParamEnv, TyCtxt};
use rustc_target::abi::{Align, HasDataLayout, Size, TargetDataLayout};
pub tcx: TyCtxt<'tcx>,
}
+/// Return the `tcx` allocation containing the initial value of the given static
+pub fn get_static(tcx: TyCtxt<'tcx>, def_id: DefId) -> InterpResult<'tcx, &'tcx Allocation> {
+ trace!("get_static: Need to compute {:?}", def_id);
+ let instance = Instance::mono(tcx, def_id);
+ let gid = GlobalId { instance, promoted: None };
+ // Use the raw query here to break validation cycles. Later uses of the static
+ // will call the full query anyway.
+ let raw_const = tcx.const_eval_raw(ty::ParamEnv::reveal_all().and(gid))?;
+ Ok(tcx.global_alloc(raw_const.alloc_id).unwrap_memory())
+}
+
impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> HasDataLayout for Memory<'mir, 'tcx, M> {
#[inline]
fn data_layout(&self) -> &TargetDataLayout {
}
/// Call this to turn untagged "global" pointers (obtained via `tcx`) into
- /// the *canonical* machine pointer to the allocation. Must never be used
- /// for any other pointers!
+ /// the machine pointer to the allocation. Must never be used
+ /// for any other pointers, nor for TLS statics.
+ ///
+ /// Using the resulting pointer represents a *direct* access to that memory
+ /// (e.g. by directly using a `static`),
+ /// as opposed to access through a pointer that was created by the program.
///
- /// This represents a *direct* access to that memory, as opposed to access
- /// through a pointer that was created by the program.
+ /// This function can fail only if `ptr` points to an `extern static`.
#[inline]
- pub fn tag_global_base_pointer(&self, ptr: Pointer) -> Pointer<M::PointerTag> {
- let id = M::canonical_alloc_id(self, ptr.alloc_id);
- ptr.with_tag(M::tag_global_base_pointer(&self.extra, id))
+ pub fn global_base_pointer(
+ &self,
+ mut ptr: Pointer,
+ ) -> InterpResult<'tcx, Pointer<M::PointerTag>> {
+ // We need to handle `extern static`.
+ let ptr = match self.tcx.get_global_alloc(ptr.alloc_id) {
+ Some(GlobalAlloc::Static(def_id)) if self.tcx.is_thread_local_static(def_id) => {
+ bug!("global memory cannot point to thread-local static")
+ }
+ Some(GlobalAlloc::Static(def_id)) if self.tcx.is_foreign_item(def_id) => {
+ ptr.alloc_id = M::extern_static_alloc_id(self, def_id)?;
+ ptr
+ }
+ _ => {
+ // No need to change the `AllocId`.
+ ptr
+ }
+ };
+ // And we need to get the tag.
+ let tag = M::tag_global_base_pointer(&self.extra, ptr.alloc_id);
+ Ok(ptr.with_tag(tag))
}
pub fn create_fn_alloc(
id
}
};
- self.tag_global_base_pointer(Pointer::from(id))
+ // Functions are global allocations, so make sure we get the right base pointer.
+ // We know this is not an `extern static` so this cannot fail.
+ self.global_base_pointer(Pointer::from(id)).unwrap()
}
pub fn allocate(
M::GLOBAL_KIND.map(MemoryKind::Machine),
"dynamically allocating global memory"
);
+ // This is a new allocation, not a new global one, so no `global_base_ptr`.
let (alloc, tag) = M::init_allocation_extra(&self.extra, id, Cow::Owned(alloc), Some(kind));
self.alloc_map.insert(id, (kind, alloc.into_owned()));
Pointer::from(id).with_tag(tag)
Some(GlobalAlloc::Function(..)) => throw_ub!(DerefFunctionPointer(id)),
None => throw_ub!(PointerUseAfterFree(id)),
Some(GlobalAlloc::Static(def_id)) => {
+ assert!(tcx.is_static(def_id));
assert!(!tcx.is_thread_local_static(def_id));
// Notice that every static has two `AllocId` that will resolve to the same
// thing here: one maps to `GlobalAlloc::Static`, this is the "lazy" ID,
// The `GlobalAlloc::Memory` branch here is still reachable though; when a static
// contains a reference to memory that was created during its evaluation (i.e., not
// to another static), those inner references only exist in "resolved" form.
- //
- // Assumes `id` is already canonical.
if tcx.is_foreign_item(def_id) {
- trace!("get_global_alloc: foreign item {:?}", def_id);
- throw_unsup!(ReadForeignStatic(def_id))
+ throw_unsup!(ReadExternStatic(def_id));
}
- trace!("get_global_alloc: Need to compute {:?}", def_id);
- let instance = Instance::mono(tcx, def_id);
- let gid = GlobalId { instance, promoted: None };
- // Use the raw query here to break validation cycles. Later uses of the static
- // will call the full query anyway.
- let raw_const =
- tcx.const_eval_raw(ty::ParamEnv::reveal_all().and(gid)).map_err(|err| {
- // no need to report anything, the const_eval call takes care of that
- // for statics
- assert!(tcx.is_static(def_id));
- err
- })?;
- // Make sure we use the ID of the resolved memory, not the lazy one!
- let id = raw_const.alloc_id;
- let allocation = tcx.global_alloc(id).unwrap_memory();
-
- (allocation, Some(def_id))
+
+ (get_static(tcx, def_id)?, Some(def_id))
}
};
M::before_access_global(memory_extra, id, alloc, def_id, is_write)?;
alloc,
M::GLOBAL_KIND.map(MemoryKind::Machine),
);
+ // Sanity check that this is the same pointer we would have gotten via `global_base_pointer`.
debug_assert_eq!(tag, M::tag_global_base_pointer(memory_extra, id));
Ok(alloc)
}
&self,
id: AllocId,
) -> InterpResult<'tcx, &Allocation<M::PointerTag, M::AllocExtra>> {
- let id = M::canonical_alloc_id(self, id);
// The error type of the inner closure here is somewhat funny. We have two
// ways of "erroring": An actual error, or because we got a reference from
// `get_global_alloc` that we can actually use directly without inserting anything anywhere.
&mut self,
id: AllocId,
) -> InterpResult<'tcx, &mut Allocation<M::PointerTag, M::AllocExtra>> {
- let id = M::canonical_alloc_id(self, id);
let tcx = self.tcx;
let memory_extra = &self.extra;
let a = self.alloc_map.get_mut_or(id, || {
id: AllocId,
liveness: AllocCheck,
) -> InterpResult<'static, (Size, Align)> {
- let id = M::canonical_alloc_id(self, id);
// # Regular allocations
// Don't use `self.get_raw` here as that will
// a) cause cycles in case `id` refers to a static
}
}
- /// Assumes `id` is already canonical.
fn get_fn_alloc(&self, id: AllocId) -> Option<FnVal<'tcx, M::ExtraFnVal>> {
trace!("reading fn ptr: {}", id);
if let Some(extra) = self.extra_fn_ptr_map.get(&id) {
if ptr.offset.bytes() != 0 {
throw_ub!(InvalidFunctionPointer(ptr.erase_tag()))
}
- let id = M::canonical_alloc_id(self, ptr.alloc_id);
- self.get_fn_alloc(id).ok_or_else(|| err_ub!(InvalidFunctionPointer(ptr.erase_tag())).into())
+ self.get_fn_alloc(ptr.alloc_id)
+ .ok_or_else(|| err_ub!(InvalidFunctionPointer(ptr.erase_tag())).into())
}
pub fn mark_immutable(&mut self, id: AllocId) -> InterpResult<'tcx> {
Ok(())
}
- /// Print an allocation and all allocations it points to, recursively.
- /// This prints directly to stderr, ignoring RUSTC_LOG! It is up to the caller to
- /// control for this.
- pub fn dump_alloc(&self, id: AllocId) {
- self.dump_allocs(vec![id]);
+ /// Create a lazy debug printer that prints the given allocation and all allocations it points
+ /// to, recursively.
+ #[must_use]
+ pub fn dump_alloc<'a>(&'a self, id: AllocId) -> DumpAllocs<'a, 'mir, 'tcx, M> {
+ self.dump_allocs(vec![id])
}
- /// Print a list of allocations and all allocations they point to, recursively.
- /// This prints directly to stderr, ignoring RUSTC_LOG! It is up to the caller to
- /// control for this.
- pub fn dump_allocs(&self, mut allocs: Vec<AllocId>) {
- // Cannot be a closure because it is generic in `Tag`, `Extra`.
- fn write_allocation_track_relocs<'tcx, Tag: Copy + fmt::Debug, Extra>(
- tcx: TyCtxt<'tcx>,
- allocs_to_print: &mut VecDeque<AllocId>,
- alloc: &Allocation<Tag, Extra>,
- ) {
- for &(_, target_id) in alloc.relocations().values() {
- allocs_to_print.push_back(target_id);
- }
- pretty::write_allocation(tcx, alloc, &mut std::io::stderr()).unwrap();
- }
-
+ /// Create a lazy debug printer for a list of allocations and all allocations they point to,
+ /// recursively.
+ #[must_use]
+ pub fn dump_allocs<'a>(&'a self, mut allocs: Vec<AllocId>) -> DumpAllocs<'a, 'mir, 'tcx, M> {
allocs.sort();
allocs.dedup();
- let mut allocs_to_print = VecDeque::from(allocs);
- // `allocs_printed` contains all allocations that we have already printed.
- let mut allocs_printed = FxHashSet::default();
-
- while let Some(id) = allocs_to_print.pop_front() {
- if !allocs_printed.insert(id) {
- // Already printed, so skip this.
- continue;
- }
-
- eprint!("{}", id);
- match self.alloc_map.get(id) {
- Some(&(kind, ref alloc)) => {
- // normal alloc
- eprint!(" ({}, ", kind);
- write_allocation_track_relocs(self.tcx, &mut allocs_to_print, alloc);
- }
- None => {
- // global alloc
- match self.tcx.get_global_alloc(id) {
- Some(GlobalAlloc::Memory(alloc)) => {
- eprint!(" (unchanged global, ");
- write_allocation_track_relocs(self.tcx, &mut allocs_to_print, alloc);
- }
- Some(GlobalAlloc::Function(func)) => {
- eprint!(" (fn: {})", func);
- }
- Some(GlobalAlloc::Static(did)) => {
- eprint!(" (static: {})", self.tcx.def_path_str(did));
- }
- None => {
- eprint!(" (deallocated)");
- }
- }
- }
- }
- eprintln!();
- }
+ DumpAllocs { mem: self, allocs }
}
/// Print leaked memory. Allocations reachable from `static_roots` or a `Global` allocation
});
let n = leaks.len();
if n > 0 {
- eprintln!("The following memory was leaked:");
- self.dump_allocs(leaks);
+ eprintln!("The following memory was leaked: {:?}", self.dump_allocs(leaks));
}
n
}
}
}
+#[doc(hidden)]
+/// There's no way to use this directly, it's just a helper struct for the `dump_alloc(s)` methods.
+pub struct DumpAllocs<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> {
+ mem: &'a Memory<'mir, 'tcx, M>,
+ allocs: Vec<AllocId>,
+}
+
+impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> std::fmt::Debug for DumpAllocs<'a, 'mir, 'tcx, M> {
+ fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ // Cannot be a closure because it is generic in `Tag`, `Extra`.
+ fn write_allocation_track_relocs<'tcx, Tag: Copy + fmt::Debug, Extra>(
+ fmt: &mut std::fmt::Formatter<'_>,
+ tcx: TyCtxt<'tcx>,
+ allocs_to_print: &mut VecDeque<AllocId>,
+ alloc: &Allocation<Tag, Extra>,
+ ) -> std::fmt::Result {
+ for &(_, target_id) in alloc.relocations().values() {
+ allocs_to_print.push_back(target_id);
+ }
+ write!(fmt, "{}", pretty::display_allocation(tcx, alloc))
+ }
+
+ let mut allocs_to_print: VecDeque<_> = self.allocs.iter().copied().collect();
+ // `allocs_printed` contains all allocations that we have already printed.
+ let mut allocs_printed = FxHashSet::default();
+
+ while let Some(id) = allocs_to_print.pop_front() {
+ if !allocs_printed.insert(id) {
+ // Already printed, so skip this.
+ continue;
+ }
+
+ write!(fmt, "{}", id)?;
+ match self.mem.alloc_map.get(id) {
+ Some(&(kind, ref alloc)) => {
+ // normal alloc
+ write!(fmt, " ({}, ", kind)?;
+ write_allocation_track_relocs(
+ &mut *fmt,
+ self.mem.tcx,
+ &mut allocs_to_print,
+ alloc,
+ )?;
+ }
+ None => {
+ // global alloc
+ match self.mem.tcx.get_global_alloc(id) {
+ Some(GlobalAlloc::Memory(alloc)) => {
+ write!(fmt, " (unchanged global, ")?;
+ write_allocation_track_relocs(
+ &mut *fmt,
+ self.mem.tcx,
+ &mut allocs_to_print,
+ alloc,
+ )?;
+ }
+ Some(GlobalAlloc::Function(func)) => {
+ write!(fmt, " (fn: {})", func)?;
+ }
+ Some(GlobalAlloc::Static(did)) => {
+ write!(fmt, " (static: {})", self.mem.tcx.def_path_str(did))?;
+ }
+ None => {
+ write!(fmt, " (deallocated)")?;
+ }
+ }
+ }
+ }
+ writeln!(fmt)?;
+ }
+ Ok(())
+ }
+}
+
/// Reading and writing.
impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
/// Reads the given number of bytes from memory. Returns them as a slice.
if compressed.no_bytes_init() {
// Fast path: If all bytes are `uninit` then there is nothing to copy. The target range
- // is marked as unititialized but we otherwise omit changing the byte representation which may
+ // is marked as uninitialized but we otherwise omit changing the byte representation which may
// be arbitrary for uninitialized bytes.
// This also avoids writing to the target bytes so that the backing allocation is never
// touched if the bytes stay uninitialized for the whole interpreter execution. On contemporary