Skip to content

Commit a25b131

Browse files
borsbors
committed
Auto merge of #95576 - DrMeepster:box_erasure, r=oli-obk
Remove dereferencing of Box from codegen Through #94043, #94414, #94873, and #95328, I've been fixing issues caused by Box being treated like a pointer when it is not a pointer. However, these PRs just introduced special cases for Box. This PR removes those special cases and instead transforms a deref of Box into a deref of the pointer it contains. Hopefully, this is the end of the Box<T, A> ICEs.
2 parents abace0a + 28ff0df commit a25b131

File tree

18 files changed

+477
-162
lines changed

18 files changed

+477
-162
lines changed

‎compiler/rustc_codegen_ssa/src/mir/operand.rs

+6-8
Original file line numberDiff line numberDiff line change
@@ -118,22 +118,20 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
118118
}
119119

120120
pub fn deref<Cx: LayoutTypeMethods<'tcx>>(self, cx: &Cx) -> PlaceRef<'tcx, V> {
121+
if self.layout.ty.is_box() {
122+
bug!("dereferencing {:?} in codegen", self.layout.ty);
123+
}
124+
121125
let projected_ty = self
122126
.layout
123127
.ty
124128
.builtin_deref(true)
125129
.unwrap_or_else(|| bug!("deref of non-pointer {:?}", self))
126130
.ty;
131+
127132
let (llptr, llextra) = match self.val {
128133
OperandValue::Immediate(llptr) => (llptr, None),
129-
OperandValue::Pair(llptr, llextra) => {
130-
// if the box's allocator isn't a ZST, then "llextra" is actually the allocator
131-
if self.layout.ty.is_box() && !self.layout.field(cx, 1).is_zst() {
132-
(llptr, None)
133-
} else {
134-
(llptr, Some(llextra))
135-
}
136-
}
134+
OperandValue::Pair(llptr, llextra) => (llptr, Some(llextra)),
137135
OperandValue::Ref(..) => bug!("Deref of by-Ref operand {:?}", self),
138136
};
139137
let layout = cx.layout_of(projected_ty);

‎compiler/rustc_codegen_ssa/src/mir/place.rs

+2-22
Original file line numberDiff line numberDiff line change
@@ -446,35 +446,15 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
446446
mir::PlaceRef { projection: &place_ref.projection[..elem.0], ..place_ref },
447447
);
448448

449-
// a box with a non-zst allocator should not be directly dereferenced
450-
if cg_base.layout.ty.is_box() && !cg_base.layout.field(cx, 1).is_zst() {
451-
// Extract `Box<T>` -> `Unique<T>` -> `NonNull<T>` -> `*const T`
452-
let ptr =
453-
cg_base.extract_field(bx, 0).extract_field(bx, 0).extract_field(bx, 0);
454-
455-
ptr.deref(bx.cx())
456-
} else {
457-
cg_base.deref(bx.cx())
458-
}
449+
cg_base.deref(bx.cx())
459450
} else {
460451
bug!("using operand local {:?} as place", place_ref);
461452
}
462453
}
463454
};
464455
for elem in place_ref.projection[base..].iter() {
465456
cg_base = match *elem {
466-
mir::ProjectionElem::Deref => {
467-
// a box with a non-zst allocator should not be directly dereferenced
468-
if cg_base.layout.ty.is_box() && !cg_base.layout.field(cx, 1).is_zst() {
469-
// Project `Box<T>` -> `Unique<T>` -> `NonNull<T>` -> `*const T`
470-
let ptr =
471-
cg_base.project_field(bx, 0).project_field(bx, 0).project_field(bx, 0);
472-
473-
bx.load_operand(ptr).deref(bx.cx())
474-
} else {
475-
bx.load_operand(cg_base).deref(bx.cx())
476-
}
477-
}
457+
mir::ProjectionElem::Deref => bx.load_operand(cg_base).deref(bx.cx()),
478458
mir::ProjectionElem::Field(ref field, _) => {
479459
cg_base.project_field(bx, field.index())
480460
}

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

+5
Original file line numberDiff line numberDiff line change
@@ -313,6 +313,11 @@ where
313313
) -> InterpResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
314314
let val = self.read_immediate(src)?;
315315
trace!("deref to {} on {:?}", val.layout.ty, *val);
316+
317+
if val.layout.ty.is_box() {
318+
bug!("dereferencing {:?}", val.layout.ty);
319+
}
320+
316321
let mplace = self.ref_to_mplace(&val)?;
317322
self.check_mplace_access(mplace, CheckInAllocMsg::DerefTest)?;
318323
Ok(mplace)

‎compiler/rustc_const_eval/src/transform/validate.rs

+64-50
Original file line numberDiff line numberDiff line change
@@ -240,65 +240,79 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
240240
context: PlaceContext,
241241
location: Location,
242242
) {
243-
if let ProjectionElem::Index(index) = elem {
244-
let index_ty = self.body.local_decls[index].ty;
245-
if index_ty != self.tcx.types.usize {
246-
self.fail(location, format!("bad index ({:?} != usize)", index_ty))
243+
match elem {
244+
ProjectionElem::Index(index) => {
245+
let index_ty = self.body.local_decls[index].ty;
246+
if index_ty != self.tcx.types.usize {
247+
self.fail(location, format!("bad index ({:?} != usize)", index_ty))
248+
}
247249
}
248-
}
249-
if let ProjectionElem::Field(f, ty) = elem {
250-
let parent = Place { local, projection: self.tcx.intern_place_elems(proj_base) };
251-
let parent_ty = parent.ty(&self.body.local_decls, self.tcx);
252-
let fail_out_of_bounds = |this: &Self, location| {
253-
this.fail(location, format!("Out of bounds field {:?} for {:?}", f, parent_ty));
254-
};
255-
let check_equal = |this: &Self, location, f_ty| {
256-
if !this.mir_assign_valid_types(ty, f_ty) {
257-
this.fail(
250+
ProjectionElem::Deref if self.mir_phase >= MirPhase::GeneratorsLowered => {
251+
let base_ty = Place::ty_from(local, proj_base, &self.body.local_decls, self.tcx).ty;
252+
253+
if base_ty.is_box() {
254+
self.fail(
255+
location,
256+
format!("{:?} dereferenced after ElaborateBoxDerefs", base_ty),
257+
)
258+
}
259+
}
260+
ProjectionElem::Field(f, ty) => {
261+
let parent = Place { local, projection: self.tcx.intern_place_elems(proj_base) };
262+
let parent_ty = parent.ty(&self.body.local_decls, self.tcx);
263+
let fail_out_of_bounds = |this: &Self, location| {
264+
this.fail(location, format!("Out of bounds field {:?} for {:?}", f, parent_ty));
265+
};
266+
let check_equal = |this: &Self, location, f_ty| {
267+
if !this.mir_assign_valid_types(ty, f_ty) {
268+
this.fail(
258269
location,
259270
format!(
260271
"Field projection `{:?}.{:?}` specified type `{:?}`, but actual type is {:?}",
261272
parent, f, ty, f_ty
262273
)
263274
)
264-
}
265-
};
266-
match parent_ty.ty.kind() {
267-
ty::Tuple(fields) => {
268-
let Some(f_ty) = fields.get(f.as_usize()) else {
269-
fail_out_of_bounds(self, location);
270-
return;
271-
};
272-
check_equal(self, location, *f_ty);
273-
}
274-
ty::Adt(adt_def, substs) => {
275-
let var = parent_ty.variant_index.unwrap_or(VariantIdx::from_u32(0));
276-
let Some(field) = adt_def.variant(var).fields.get(f.as_usize()) else {
277-
fail_out_of_bounds(self, location);
278-
return;
279-
};
280-
check_equal(self, location, field.ty(self.tcx, substs));
281-
}
282-
ty::Closure(_, substs) => {
283-
let substs = substs.as_closure();
284-
let Some(f_ty) = substs.upvar_tys().nth(f.as_usize()) else {
285-
fail_out_of_bounds(self, location);
286-
return;
287-
};
288-
check_equal(self, location, f_ty);
289-
}
290-
ty::Generator(_, substs, _) => {
291-
let substs = substs.as_generator();
292-
let Some(f_ty) = substs.upvar_tys().nth(f.as_usize()) else {
293-
fail_out_of_bounds(self, location);
294-
return;
295-
};
296-
check_equal(self, location, f_ty);
297-
}
298-
_ => {
299-
self.fail(location, format!("{:?} does not have fields", parent_ty.ty));
275+
}
276+
};
277+
278+
match parent_ty.ty.kind() {
279+
ty::Tuple(fields) => {
280+
let Some(f_ty) = fields.get(f.as_usize()) else {
281+
fail_out_of_bounds(self, location);
282+
return;
283+
};
284+
check_equal(self, location, *f_ty);
285+
}
286+
ty::Adt(adt_def, substs) => {
287+
let var = parent_ty.variant_index.unwrap_or(VariantIdx::from_u32(0));
288+
let Some(field) = adt_def.variant(var).fields.get(f.as_usize()) else {
289+
fail_out_of_bounds(self, location);
290+
return;
291+
};
292+
check_equal(self, location, field.ty(self.tcx, substs));
293+
}
294+
ty::Closure(_, substs) => {
295+
let substs = substs.as_closure();
296+
let Some(f_ty) = substs.upvar_tys().nth(f.as_usize()) else {
297+
fail_out_of_bounds(self, location);
298+
return;
299+
};
300+
check_equal(self, location, f_ty);
301+
}
302+
ty::Generator(_, substs, _) => {
303+
let substs = substs.as_generator();
304+
let Some(f_ty) = substs.upvar_tys().nth(f.as_usize()) else {
305+
fail_out_of_bounds(self, location);
306+
return;
307+
};
308+
check_equal(self, location, f_ty);
309+
}
310+
_ => {
311+
self.fail(location, format!("{:?} does not have fields", parent_ty.ty));
312+
}
300313
}
301314
}
315+
_ => {}
302316
}
303317
self.super_projection_elem(local, proj_base, elem, context, location);
304318
}

‎compiler/rustc_index/src/bit_set.rs

+12
Original file line numberDiff line numberDiff line change
@@ -340,6 +340,12 @@ impl<T: Idx> BitRelations<BitSet<T>> for BitSet<T> {
340340
}
341341
}
342342

343+
impl<T: Idx> From<GrowableBitSet<T>> for BitSet<T> {
344+
fn from(bit_set: GrowableBitSet<T>) -> Self {
345+
bit_set.bit_set
346+
}
347+
}
348+
343349
/// A fixed-size bitset type with a partially dense, partially sparse
344350
/// representation. The bitset is broken into chunks, and chunks that are all
345351
/// zeros or all ones are represented and handled very efficiently.
@@ -1542,6 +1548,12 @@ impl<T: Idx> GrowableBitSet<T> {
15421548
}
15431549
}
15441550

1551+
impl<T: Idx> From<BitSet<T>> for GrowableBitSet<T> {
1552+
fn from(bit_set: BitSet<T>) -> Self {
1553+
Self { bit_set }
1554+
}
1555+
}
1556+
15451557
/// A fixed-size 2D bit matrix type with a dense representation.
15461558
///
15471559
/// `R` and `C` are index types used to identify rows and columns respectively;

‎compiler/rustc_middle/src/mir/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -195,6 +195,7 @@ pub enum MirPhase {
195195
/// Beginning with this phase, the following variants are disallowed:
196196
/// * [`TerminatorKind::Yield`](terminator::TerminatorKind::Yield)
197197
/// * [`TerminatorKind::GeneratorDrop`](terminator::TerminatorKind::GeneratorDrop)
198+
/// * [`ProjectionElem::Deref`] of `Box`
198199
GeneratorsLowered = 6,
199200
Optimized = 7,
200201
}

‎compiler/rustc_mir_dataflow/src/elaborate_drops.rs

+12-1
Original file line numberDiff line numberDiff line change
@@ -410,7 +410,18 @@ where
410410
fn open_drop_for_box(&mut self, adt: ty::AdtDef<'tcx>, substs: SubstsRef<'tcx>) -> BasicBlock {
411411
debug!("open_drop_for_box({:?}, {:?}, {:?})", self, adt, substs);
412412

413-
let interior = self.tcx().mk_place_deref(self.place);
413+
// drop glue is sent straight to codegen
414+
// box cannot be directly dereferenced
415+
let unique_ty = adt.non_enum_variant().fields[0].ty(self.tcx(), substs);
416+
let nonnull_ty =
417+
unique_ty.ty_adt_def().unwrap().non_enum_variant().fields[0].ty(self.tcx(), substs);
418+
let ptr_ty = self.tcx().mk_imm_ptr(substs[0].expect_ty());
419+
420+
let unique_place = self.tcx().mk_place_field(self.place, Field::new(0), unique_ty);
421+
let nonnull_place = self.tcx().mk_place_field(unique_place, Field::new(0), nonnull_ty);
422+
let ptr_place = self.tcx().mk_place_field(nonnull_place, Field::new(0), ptr_ty);
423+
let interior = self.tcx().mk_place_deref(ptr_place);
424+
414425
let interior_path = self.elaborator.deref_subpath(self.path);
415426

416427
let succ = self.box_free_block(adt, substs, self.succ, self.unwind);

0 commit comments

Comments
 (0)