Skip to content

Commit 2900ba1

Browse files
RalfJungRalfJung
committed
miri: fix ICE when running out of address space
1 parent 7ff69b4 commit 2900ba1

File tree

9 files changed

+54
-33
lines changed

9 files changed

+54
-33
lines changed

‎compiler/rustc_const_eval/src/interpret/intrinsics/caller_location.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -78,13 +78,16 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
7878
col: u32,
7979
) -> MPlaceTy<'tcx, M::Provenance> {
8080
let loc_details = &self.tcx.sess.opts.unstable_opts.location_detail;
81+
// This can fail if rustc runs out of memory right here. Trying to emit an error would be
82+
// pointless, since that would require allocating more memory than these short strings.
8183
let file = if loc_details.file {
8284
self.allocate_str(filename.as_str(), MemoryKind::CallerLocation, Mutability::Not)
85+
.unwrap()
8386
} else {
8487
// FIXME: This creates a new allocation each time. It might be preferable to
8588
// perform this allocation only once, and re-use the `MPlaceTy`.
8689
// See https://github.com/rust-lang/rust/pull/89920#discussion_r730012398
87-
self.allocate_str("<redacted>", MemoryKind::CallerLocation, Mutability::Not)
90+
self.allocate_str("<redacted>", MemoryKind::CallerLocation, Mutability::Not).unwrap()
8891
};
8992
let line = if loc_details.line { Scalar::from_u32(line) } else { Scalar::from_u32(0) };
9093
let col = if loc_details.column { Scalar::from_u32(col) } else { Scalar::from_u32(0) };
@@ -95,8 +98,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
9598
.bound_type_of(self.tcx.require_lang_item(LangItem::PanicLocation, None))
9699
.subst(*self.tcx, self.tcx.mk_substs([self.tcx.lifetimes.re_erased.into()].iter()));
97100
let loc_layout = self.layout_of(loc_ty).unwrap();
98-
// This can fail if rustc runs out of memory right here. Trying to emit an error would be
99-
// pointless, since that would require allocating more memory than a Location.
100101
let location = self.allocate(loc_layout, MemoryKind::CallerLocation).unwrap();
101102

102103
// Initialize fields.

‎compiler/rustc_const_eval/src/interpret/machine.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -291,7 +291,7 @@ pub trait Machine<'mir, 'tcx>: Sized {
291291
fn adjust_alloc_base_pointer(
292292
ecx: &InterpCx<'mir, 'tcx, Self>,
293293
ptr: Pointer,
294-
) -> Pointer<Self::Provenance>;
294+
) -> InterpResult<'tcx, Pointer<Self::Provenance>>;
295295

296296
/// "Int-to-pointer cast"
297297
fn ptr_from_addr_cast(
@@ -505,8 +505,8 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) {
505505
fn adjust_alloc_base_pointer(
506506
_ecx: &InterpCx<$mir, $tcx, Self>,
507507
ptr: Pointer<AllocId>,
508-
) -> Pointer<AllocId> {
509-
ptr
508+
) -> InterpResult<$tcx, Pointer<AllocId>> {
509+
Ok(ptr)
510510
}
511511

512512
#[inline(always)]

‎compiler/rustc_const_eval/src/interpret/memory.rs

+5-7
Original file line numberDiff line numberDiff line change
@@ -171,7 +171,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
171171
_ => {}
172172
}
173173
// And we need to get the provenance.
174-
Ok(M::adjust_alloc_base_pointer(self, ptr))
174+
M::adjust_alloc_base_pointer(self, ptr)
175175
}
176176

177177
pub fn create_fn_alloc_ptr(
@@ -200,8 +200,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
200200
kind: MemoryKind<M::MemoryKind>,
201201
) -> InterpResult<'tcx, Pointer<M::Provenance>> {
202202
let alloc = Allocation::uninit(size, align, M::PANIC_ON_ALLOC_FAIL)?;
203-
// We can `unwrap` since `alloc` contains no pointers.
204-
Ok(self.allocate_raw_ptr(alloc, kind).unwrap())
203+
self.allocate_raw_ptr(alloc, kind)
205204
}
206205

207206
pub fn allocate_bytes_ptr(
@@ -210,10 +209,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
210209
align: Align,
211210
kind: MemoryKind<M::MemoryKind>,
212211
mutability: Mutability,
213-
) -> Pointer<M::Provenance> {
212+
) -> InterpResult<'tcx, Pointer<M::Provenance>> {
214213
let alloc = Allocation::from_bytes(bytes, align, mutability);
215-
// We can `unwrap` since `alloc` contains no pointers.
216-
self.allocate_raw_ptr(alloc, kind).unwrap()
214+
self.allocate_raw_ptr(alloc, kind)
217215
}
218216

219217
/// This can fail only of `alloc` contains provenance.
@@ -230,7 +228,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
230228
);
231229
let alloc = M::adjust_allocation(self, id, Cow::Owned(alloc), Some(kind))?;
232230
self.memory.alloc_map.insert(id, (kind, alloc.into_owned()));
233-
Ok(M::adjust_alloc_base_pointer(self, Pointer::from(id)))
231+
M::adjust_alloc_base_pointer(self, Pointer::from(id))
234232
}
235233

236234
pub fn reallocate_ptr(

‎compiler/rustc_const_eval/src/interpret/place.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -754,8 +754,8 @@ where
754754
str: &str,
755755
kind: MemoryKind<M::MemoryKind>,
756756
mutbl: Mutability,
757-
) -> MPlaceTy<'tcx, M::Provenance> {
758-
let ptr = self.allocate_bytes_ptr(str.as_bytes(), Align::ONE, kind, mutbl);
757+
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::Provenance>> {
758+
let ptr = self.allocate_bytes_ptr(str.as_bytes(), Align::ONE, kind, mutbl)?;
759759
let meta = Scalar::from_machine_usize(u64::try_from(str.len()).unwrap(), self);
760760
let mplace = MemPlace { ptr: ptr.into(), meta: MemPlaceMeta::Meta(meta) };
761761

@@ -764,7 +764,7 @@ where
764764
ty::TypeAndMut { ty: self.tcx.types.str_, mutbl },
765765
);
766766
let layout = self.layout_of(ty).unwrap();
767-
MPlaceTy { mplace, layout, align: layout.align.abi }
767+
Ok(MPlaceTy { mplace, layout, align: layout.align.abi })
768768
}
769769

770770
/// Writes the discriminant of the given variant.

‎compiler/rustc_middle/src/mir/interpret/error.rs

+6-1
Original file line numberDiff line numberDiff line change
@@ -430,8 +430,10 @@ pub enum ResourceExhaustionInfo {
430430
///
431431
/// The exact limit is set by the `const_eval_limit` attribute.
432432
StepLimitReached,
433-
/// There is not enough memory to perform an allocation.
433+
/// There is not enough memory (on the host) to perform an allocation.
434434
MemoryExhausted,
435+
/// The address space (of the target) is full.
436+
AddressSpaceFull,
435437
}
436438

437439
impl fmt::Display for ResourceExhaustionInfo {
@@ -447,6 +449,9 @@ impl fmt::Display for ResourceExhaustionInfo {
447449
MemoryExhausted => {
448450
write!(f, "tried to allocate more memory than available to compiler")
449451
}
452+
AddressSpaceFull => {
453+
write!(f, "there are no more free addresses in the address space")
454+
}
450455
}
451456
}
452457
}

‎src/tools/miri/src/intptrcast.rs

+26-9
Original file line numberDiff line numberDiff line change
@@ -162,11 +162,14 @@ impl<'mir, 'tcx> GlobalStateInner {
162162
Ok(Pointer::new(Some(Provenance::Wildcard), Size::from_bytes(addr)))
163163
}
164164

165-
fn alloc_base_addr(ecx: &MiriInterpCx<'mir, 'tcx>, alloc_id: AllocId) -> u64 {
165+
fn alloc_base_addr(
166+
ecx: &MiriInterpCx<'mir, 'tcx>,
167+
alloc_id: AllocId,
168+
) -> InterpResult<'tcx, u64> {
166169
let mut global_state = ecx.machine.intptrcast.borrow_mut();
167170
let global_state = &mut *global_state;
168171

169-
match global_state.base_addr.entry(alloc_id) {
172+
Ok(match global_state.base_addr.entry(alloc_id) {
170173
Entry::Occupied(entry) => *entry.get(),
171174
Entry::Vacant(entry) => {
172175
// There is nothing wrong with a raw pointer being cast to an integer only after
@@ -181,7 +184,10 @@ impl<'mir, 'tcx> GlobalStateInner {
181184
rng.gen_range(0..16)
182185
};
183186
// From next_base_addr + slack, round up to adjust for alignment.
184-
let base_addr = global_state.next_base_addr.checked_add(slack).unwrap();
187+
let base_addr = global_state
188+
.next_base_addr
189+
.checked_add(slack)
190+
.ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
185191
let base_addr = Self::align_addr(base_addr, align.bytes());
186192
entry.insert(base_addr);
187193
trace!(
@@ -197,24 +203,33 @@ impl<'mir, 'tcx> GlobalStateInner {
197203
// of at least 1 to avoid two allocations having the same base address.
198204
// (The logic in `alloc_id_from_addr` assumes unique addresses, and different
199205
// function/vtable pointers need to be distinguishable!)
200-
global_state.next_base_addr = base_addr.checked_add(max(size.bytes(), 1)).unwrap();
206+
global_state.next_base_addr = base_addr
207+
.checked_add(max(size.bytes(), 1))
208+
.ok_or_else(|| err_exhaust!(AddressSpaceFull))?;
209+
// Even if `Size` didn't overflow, we might still have filled up the address space.
210+
if global_state.next_base_addr > ecx.machine_usize_max() {
211+
throw_exhaust!(AddressSpaceFull);
212+
}
201213
// Given that `next_base_addr` increases in each allocation, pushing the
202214
// corresponding tuple keeps `int_to_ptr_map` sorted
203215
global_state.int_to_ptr_map.push((base_addr, alloc_id));
204216

205217
base_addr
206218
}
207-
}
219+
})
208220
}
209221

210222
/// Convert a relative (tcx) pointer to an absolute address.
211-
pub fn rel_ptr_to_addr(ecx: &MiriInterpCx<'mir, 'tcx>, ptr: Pointer<AllocId>) -> u64 {
223+
pub fn rel_ptr_to_addr(
224+
ecx: &MiriInterpCx<'mir, 'tcx>,
225+
ptr: Pointer<AllocId>,
226+
) -> InterpResult<'tcx, u64> {
212227
let (alloc_id, offset) = ptr.into_parts(); // offset is relative (AllocId provenance)
213-
let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id);
228+
let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id)?;
214229

215230
// Add offset with the right kind of pointer-overflowing arithmetic.
216231
let dl = ecx.data_layout();
217-
dl.overflowing_offset(base_addr, offset.bytes()).0
232+
Ok(dl.overflowing_offset(base_addr, offset.bytes()).0)
218233
}
219234

220235
/// When a pointer is used for a memory access, this computes where in which allocation the
@@ -232,7 +247,9 @@ impl<'mir, 'tcx> GlobalStateInner {
232247
GlobalStateInner::alloc_id_from_addr(ecx, addr.bytes())?
233248
};
234249

235-
let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id);
250+
// This cannot fail: since we already have a pointer with that provenance, rel_ptr_to_addr
251+
// must have been called in the past.
252+
let base_addr = GlobalStateInner::alloc_base_addr(ecx, alloc_id).unwrap();
236253

237254
// Wrapping "addr - base_addr"
238255
let dl = ecx.data_layout();

‎src/tools/miri/src/machine.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -971,7 +971,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
971971
fn adjust_alloc_base_pointer(
972972
ecx: &MiriInterpCx<'mir, 'tcx>,
973973
ptr: Pointer<AllocId>,
974-
) -> Pointer<Provenance> {
974+
) -> InterpResult<'tcx, Pointer<Provenance>> {
975975
if cfg!(debug_assertions) {
976976
// The machine promises to never call us on thread-local or extern statics.
977977
let alloc_id = ptr.provenance;
@@ -985,17 +985,17 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for MiriMachine<'mir, 'tcx> {
985985
_ => {}
986986
}
987987
}
988-
let absolute_addr = intptrcast::GlobalStateInner::rel_ptr_to_addr(ecx, ptr);
988+
let absolute_addr = intptrcast::GlobalStateInner::rel_ptr_to_addr(ecx, ptr)?;
989989
let tag = if let Some(borrow_tracker) = &ecx.machine.borrow_tracker {
990990
borrow_tracker.borrow_mut().base_ptr_tag(ptr.provenance, &ecx.machine)
991991
} else {
992992
// Value does not matter, SB is disabled
993993
BorTag::default()
994994
};
995-
Pointer::new(
995+
Ok(Pointer::new(
996996
Provenance::Concrete { alloc_id: ptr.provenance, tag },
997997
Size::from_bytes(absolute_addr),
998-
)
998+
))
999999
}
10001000

10011001
#[inline(always)]

‎src/tools/miri/src/shims/backtrace.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -190,9 +190,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
190190
0 => {
191191
// These are "mutable" allocations as we consider them to be owned by the callee.
192192
let name_alloc =
193-
this.allocate_str(&name, MiriMemoryKind::Rust.into(), Mutability::Mut);
193+
this.allocate_str(&name, MiriMemoryKind::Rust.into(), Mutability::Mut)?;
194194
let filename_alloc =
195-
this.allocate_str(&filename, MiriMemoryKind::Rust.into(), Mutability::Mut);
195+
this.allocate_str(&filename, MiriMemoryKind::Rust.into(), Mutability::Mut)?;
196196

197197
this.write_immediate(
198198
name_alloc.to_ref(this),

‎src/tools/miri/src/shims/panic.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -172,7 +172,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
172172
let this = self.eval_context_mut();
173173

174174
// First arg: message.
175-
let msg = this.allocate_str(msg, MiriMemoryKind::Machine.into(), Mutability::Not);
175+
let msg = this.allocate_str(msg, MiriMemoryKind::Machine.into(), Mutability::Not)?;
176176

177177
// Call the lang item.
178178
let panic = this.tcx.lang_items().panic_fn().unwrap();

0 commit comments

Comments
 (0)