Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit a86d3a7

Browse files
crlf0710crlf0710
committedJun 14, 2021
Refactor to make interpreter and codegen backend neutral to vtable internal representation.
1 parent 1483156 commit a86d3a7

File tree

10 files changed

+248
-179
lines changed

10 files changed

+248
-179
lines changed
 

‎compiler/rustc_codegen_cranelift/src/vtable.rs

Lines changed: 38 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,7 @@
44
// FIXME dedup this logic between miri, cg_llvm and cg_clif
55

66
use crate::prelude::*;
7-
8-
const DROP_FN_INDEX: usize = 0;
9-
const SIZE_INDEX: usize = 1;
10-
const ALIGN_INDEX: usize = 2;
7+
use ty::VtblEntry;
118

129
fn vtable_memflags() -> MemFlags {
1310
let mut flags = MemFlags::trusted(); // A vtable access is always aligned and will never trap.
@@ -21,7 +18,7 @@ pub(crate) fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) ->
2118
pointer_ty(fx.tcx),
2219
vtable_memflags(),
2320
vtable,
24-
(DROP_FN_INDEX * usize_size) as i32,
21+
(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE * usize_size) as i32,
2522
)
2623
}
2724

@@ -31,7 +28,7 @@ pub(crate) fn size_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) -> Val
3128
pointer_ty(fx.tcx),
3229
vtable_memflags(),
3330
vtable,
34-
(SIZE_INDEX * usize_size) as i32,
31+
(ty::COMMON_VTABLE_ENTRIES_SIZE * usize_size) as i32,
3532
)
3633
}
3734

@@ -41,7 +38,7 @@ pub(crate) fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) -
4138
pointer_ty(fx.tcx),
4239
vtable_memflags(),
4340
vtable,
44-
(ALIGN_INDEX * usize_size) as i32,
41+
(ty::COMMON_VTABLE_ENTRIES_SIZE * usize_size) as i32,
4542
)
4643
}
4744

@@ -62,7 +59,7 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
6259
pointer_ty(fx.tcx),
6360
vtable_memflags(),
6461
vtable,
65-
((idx + 3) * usize_size as usize) as i32,
62+
(idx * usize_size as usize) as i32,
6663
);
6764
(ptr, func_ref)
6865
}
@@ -98,42 +95,49 @@ fn build_vtable<'tcx>(
9895
Instance::resolve_drop_in_place(tcx, layout.ty).polymorphize(fx.tcx),
9996
);
10097

101-
let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None];
102-
103-
let methods_root;
104-
let methods = if let Some(trait_ref) = trait_ref {
105-
methods_root = tcx.vtable_methods(trait_ref.with_self_ty(tcx, layout.ty));
106-
methods_root.iter()
98+
let vtable_entries = if let Some(trait_ref) = trait_ref {
99+
tcx.vtable_entries(trait_ref.with_self_ty(tcx, layout.ty))
107100
} else {
108-
(&[]).iter()
101+
ty::COMMON_VTABLE_ENTRIES
109102
};
110-
let methods = methods.cloned().map(|opt_mth| {
111-
opt_mth.map(|(def_id, substs)| {
112-
import_function(
113-
tcx,
114-
fx.module,
115-
Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs)
116-
.unwrap()
117-
.polymorphize(fx.tcx),
118-
)
119-
})
120-
});
121-
components.extend(methods);
122103

123104
let mut data_ctx = DataContext::new();
124105
let mut data = ::std::iter::repeat(0u8)
125-
.take(components.len() * usize_size)
106+
.take(vtable_entries.len() * usize_size)
126107
.collect::<Vec<u8>>()
127108
.into_boxed_slice();
128109

129-
write_usize(fx.tcx, &mut data, SIZE_INDEX, layout.size.bytes());
130-
write_usize(fx.tcx, &mut data, ALIGN_INDEX, layout.align.abi.bytes());
110+
for (idx, entry) in vtable_entries.iter().enumerate() {
111+
match entry {
112+
VtblEntry::MetadataSize => {
113+
write_usize(fx.tcx, &mut data, idx, layout.size.bytes());
114+
}
115+
VtblEntry::MetadataAlign => {
116+
write_usize(fx.tcx, &mut data, idx, layout.align.abi.bytes());
117+
}
118+
VtblEntry::MetadataDropInPlace | VtblEntry::Vacant | VtblEntry::Method(_, _) => {}
119+
}
120+
}
131121
data_ctx.define(data);
132122

133-
for (i, component) in components.into_iter().enumerate() {
134-
if let Some(func_id) = component {
135-
let func_ref = fx.module.declare_func_in_data(func_id, &mut data_ctx);
136-
data_ctx.write_function_addr((i * usize_size) as u32, func_ref);
123+
for (idx, entry) in vtable_entries.iter().enumerate() {
124+
match entry {
125+
VtblEntry::MetadataDropInPlace => {
126+
let func_ref = fx.module.declare_func_in_data(drop_in_place_fn, &mut data_ctx);
127+
data_ctx.write_function_addr((idx * usize_size) as u32, func_ref);
128+
}
129+
VtblEntry::Method(def_id, substs) => {
130+
let func_id = import_function(
131+
tcx,
132+
fx.module,
133+
Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), *def_id, substs)
134+
.unwrap()
135+
.polymorphize(fx.tcx),
136+
);
137+
let func_ref = fx.module.declare_func_in_data(func_id, &mut data_ctx);
138+
data_ctx.write_function_addr((idx * usize_size) as u32, func_ref);
139+
}
140+
VtblEntry::MetadataSize | VtblEntry::MetadataAlign | VtblEntry::Vacant => {}
137141
}
138142
}
139143

‎compiler/rustc_codegen_ssa/src/glue.rs

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,12 @@ pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
2323
ty::Dynamic(..) => {
2424
// load size/align from vtable
2525
let vtable = info.unwrap();
26-
(meth::SIZE.get_usize(bx, vtable), meth::ALIGN.get_usize(bx, vtable))
26+
(
27+
meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_SIZE)
28+
.get_usize(bx, vtable),
29+
meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_ALIGN)
30+
.get_usize(bx, vtable),
31+
)
2732
}
2833
ty::Slice(_) | ty::Str => {
2934
let unit = layout.field(bx, 0);

‎compiler/rustc_codegen_ssa/src/meth.rs

Lines changed: 23 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,14 @@
11
use crate::traits::*;
22

3-
use rustc_middle::ty::{self, Instance, Ty};
3+
use rustc_middle::ty::{self, Instance, Ty, VtblEntry, COMMON_VTABLE_ENTRIES};
44
use rustc_target::abi::call::FnAbi;
55

66
#[derive(Copy, Clone, Debug)]
77
pub struct VirtualIndex(u64);
88

9-
pub const DESTRUCTOR: VirtualIndex = VirtualIndex(0);
10-
pub const SIZE: VirtualIndex = VirtualIndex(1);
11-
pub const ALIGN: VirtualIndex = VirtualIndex(2);
12-
139
impl<'a, 'tcx> VirtualIndex {
1410
pub fn from_index(index: usize) -> Self {
15-
VirtualIndex(index as u64 + 3)
11+
VirtualIndex(index as u64)
1612
}
1713

1814
pub fn get_fn<Bx: BuilderMethods<'a, 'tcx>>(
@@ -77,43 +73,38 @@ pub fn get_vtable<'tcx, Cx: CodegenMethods<'tcx>>(
7773
// Not in the cache; build it.
7874
let nullptr = cx.const_null(cx.type_i8p_ext(cx.data_layout().instruction_address_space));
7975

80-
let methods_root;
81-
let methods = if let Some(trait_ref) = trait_ref {
82-
methods_root = tcx.vtable_methods(trait_ref.with_self_ty(tcx, ty));
83-
methods_root.iter()
76+
let vtable_entries = if let Some(trait_ref) = trait_ref {
77+
tcx.vtable_entries(trait_ref.with_self_ty(tcx, ty))
8478
} else {
85-
(&[]).iter()
79+
COMMON_VTABLE_ENTRIES
8680
};
8781

88-
let methods = methods.cloned().map(|opt_mth| {
89-
opt_mth.map_or(nullptr, |(def_id, substs)| {
90-
cx.get_fn_addr(
82+
let layout = cx.layout_of(ty);
83+
// /////////////////////////////////////////////////////////////////////////////////////////////
84+
// If you touch this code, be sure to also make the corresponding changes to
85+
// `get_vtable` in `rust_mir/interpret/traits.rs`.
86+
// /////////////////////////////////////////////////////////////////////////////////////////////
87+
let components: Vec<_> = vtable_entries
88+
.iter()
89+
.map(|entry| match entry {
90+
VtblEntry::MetadataDropInPlace => {
91+
cx.get_fn_addr(Instance::resolve_drop_in_place(cx.tcx(), ty))
92+
}
93+
VtblEntry::MetadataSize => cx.const_usize(layout.size.bytes()),
94+
VtblEntry::MetadataAlign => cx.const_usize(layout.align.abi.bytes()),
95+
VtblEntry::Vacant => nullptr,
96+
VtblEntry::Method(def_id, substs) => cx.get_fn_addr(
9197
ty::Instance::resolve_for_vtable(
9298
cx.tcx(),
9399
ty::ParamEnv::reveal_all(),
94-
def_id,
100+
*def_id,
95101
substs,
96102
)
97103
.unwrap()
98104
.polymorphize(cx.tcx()),
99-
)
105+
),
100106
})
101-
});
102-
103-
let layout = cx.layout_of(ty);
104-
// /////////////////////////////////////////////////////////////////////////////////////////////
105-
// If you touch this code, be sure to also make the corresponding changes to
106-
// `get_vtable` in `rust_mir/interpret/traits.rs`.
107-
// /////////////////////////////////////////////////////////////////////////////////////////////
108-
let components: Vec<_> = [
109-
cx.get_fn_addr(Instance::resolve_drop_in_place(cx.tcx(), ty)),
110-
cx.const_usize(layout.size.bytes()),
111-
cx.const_usize(layout.align.abi.bytes()),
112-
]
113-
.iter()
114-
.cloned()
115-
.chain(methods)
116-
.collect();
107+
.collect();
117108

118109
let vtable_const = cx.const_struct(&components, false);
119110
let align = cx.data_layout().pointer_align.abi;

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

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -332,7 +332,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
332332
let fn_abi = FnAbi::of_instance(&bx, virtual_drop, &[]);
333333
let vtable = args[1];
334334
args = &args[..1];
335-
(meth::DESTRUCTOR.get_fn(&mut bx, vtable, &fn_abi), fn_abi)
335+
(
336+
meth::VirtualIndex::from_index(ty::COMMON_VTABLE_ENTRIES_DROPINPLACE)
337+
.get_fn(&mut bx, vtable, &fn_abi),
338+
fn_abi,
339+
)
336340
}
337341
_ => (bx.get_fn_addr(drop_fn), FnAbi::of_instance(&bx, drop_fn, &[])),
338342
};

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

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -959,9 +959,9 @@ rustc_queries! {
959959
desc { |tcx| "checking if item has mir available: `{}`", tcx.def_path_str(key) }
960960
}
961961

962-
query vtable_methods(key: ty::PolyTraitRef<'tcx>)
963-
-> &'tcx [Option<(DefId, SubstsRef<'tcx>)>] {
964-
desc { |tcx| "finding all methods for trait {}", tcx.def_path_str(key.def_id()) }
962+
query vtable_entries(key: ty::PolyTraitRef<'tcx>)
963+
-> &'tcx [ty::VtblEntry<'tcx>] {
964+
desc { |tcx| "finding all vtable entries for trait {}", tcx.def_path_str(key.def_id()) }
965965
}
966966

967967
query codegen_fulfill_obligation(

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2009,3 +2009,19 @@ impl<'tcx> fmt::Debug for SymbolName<'tcx> {
20092009
fmt::Display::fmt(&self.name, fmt)
20102010
}
20112011
}
2012+
2013+
#[derive(Clone, Copy, Debug, PartialEq, HashStable)]
2014+
pub enum VtblEntry<'tcx> {
2015+
MetadataDropInPlace,
2016+
MetadataSize,
2017+
MetadataAlign,
2018+
Vacant,
2019+
Method(DefId, SubstsRef<'tcx>),
2020+
}
2021+
2022+
pub const COMMON_VTABLE_ENTRIES: &[VtblEntry<'_>] =
2023+
&[VtblEntry::MetadataDropInPlace, VtblEntry::MetadataSize, VtblEntry::MetadataAlign];
2024+
2025+
pub const COMMON_VTABLE_ENTRIES_DROPINPLACE: usize = 0;
2026+
pub const COMMON_VTABLE_ENTRIES_SIZE: usize = 1;
2027+
pub const COMMON_VTABLE_ENTRIES_ALIGN: usize = 2;

‎compiler/rustc_mir/src/interpret/traits.rs

Lines changed: 57 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,10 @@
11
use std::convert::TryFrom;
22

33
use rustc_middle::mir::interpret::{InterpResult, Pointer, PointerArithmetic, Scalar};
4-
use rustc_middle::ty::{self, Instance, Ty};
4+
use rustc_middle::ty::{
5+
self, Instance, Ty, VtblEntry, COMMON_VTABLE_ENTRIES, COMMON_VTABLE_ENTRIES_ALIGN,
6+
COMMON_VTABLE_ENTRIES_DROPINPLACE, COMMON_VTABLE_ENTRIES_SIZE,
7+
};
58
use rustc_target::abi::{Align, LayoutOf, Size};
69

710
use super::util::ensure_monomorphic_enough;
@@ -35,13 +38,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
3538
return Ok(vtable);
3639
}
3740

38-
let methods = if let Some(poly_trait_ref) = poly_trait_ref {
41+
let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
3942
let trait_ref = poly_trait_ref.with_self_ty(*self.tcx, ty);
4043
let trait_ref = self.tcx.erase_regions(trait_ref);
4144

42-
self.tcx.vtable_methods(trait_ref)
45+
self.tcx.vtable_entries(trait_ref)
4346
} else {
44-
&[]
47+
COMMON_VTABLE_ENTRIES
4548
};
4649

4750
let layout = self.layout_of(ty)?;
@@ -56,38 +59,41 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
5659
// If you touch this code, be sure to also make the corresponding changes to
5760
// `get_vtable` in `rust_codegen_llvm/meth.rs`.
5861
// /////////////////////////////////////////////////////////////////////////////////////////
59-
let vtable_size = ptr_size * u64::try_from(methods.len()).unwrap().checked_add(3).unwrap();
62+
let vtable_size = ptr_size * u64::try_from(vtable_entries.len()).unwrap();
6063
let vtable = self.memory.allocate(vtable_size, ptr_align, MemoryKind::Vtable);
6164

6265
let drop = Instance::resolve_drop_in_place(tcx, ty);
6366
let drop = self.memory.create_fn_alloc(FnVal::Instance(drop));
6467

65-
// Prepare the fn ptrs we will write into the vtable later.
66-
let fn_ptrs = methods
67-
.iter()
68-
.enumerate() // remember the original position
69-
.filter_map(|(i, method)| {
70-
if let Some((def_id, substs)) = method { Some((i, def_id, substs)) } else { None }
71-
})
72-
.map(|(i, def_id, substs)| {
73-
let instance =
74-
ty::Instance::resolve_for_vtable(tcx, self.param_env, *def_id, substs)
75-
.ok_or_else(|| err_inval!(TooGeneric))?;
76-
Ok((i, self.memory.create_fn_alloc(FnVal::Instance(instance))))
77-
})
78-
.collect::<InterpResult<'tcx, Vec<(usize, Pointer<M::PointerTag>)>>>()?;
79-
8068
// No need to do any alignment checks on the memory accesses below, because we know the
8169
// allocation is correctly aligned as we created it above. Also we're only offsetting by
8270
// multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
71+
let scalars = vtable_entries
72+
.iter()
73+
.map(|entry| -> InterpResult<'tcx, _> {
74+
match entry {
75+
VtblEntry::MetadataDropInPlace => Ok(Some(drop.into())),
76+
VtblEntry::MetadataSize => Ok(Some(Scalar::from_uint(size, ptr_size).into())),
77+
VtblEntry::MetadataAlign => Ok(Some(Scalar::from_uint(align, ptr_size).into())),
78+
VtblEntry::Vacant => Ok(None),
79+
VtblEntry::Method(def_id, substs) => {
80+
// Prepare the fn ptr we write into the vtable.
81+
let instance =
82+
ty::Instance::resolve_for_vtable(tcx, self.param_env, *def_id, substs)
83+
.ok_or_else(|| err_inval!(TooGeneric))?;
84+
let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
85+
Ok(Some(fn_ptr.into()))
86+
}
87+
}
88+
})
89+
.collect::<Result<Vec<_>, _>>()?;
8390
let mut vtable_alloc =
8491
self.memory.get_mut(vtable.into(), vtable_size, ptr_align)?.expect("not a ZST");
85-
vtable_alloc.write_ptr_sized(ptr_size * 0, drop.into())?;
86-
vtable_alloc.write_ptr_sized(ptr_size * 1, Scalar::from_uint(size, ptr_size).into())?;
87-
vtable_alloc.write_ptr_sized(ptr_size * 2, Scalar::from_uint(align, ptr_size).into())?;
88-
89-
for (i, fn_ptr) in fn_ptrs.into_iter() {
90-
vtable_alloc.write_ptr_sized(ptr_size * (3 + i as u64), fn_ptr.into())?;
92+
for (idx, scalar) in scalars.into_iter().enumerate() {
93+
if let Some(scalar) = scalar {
94+
let idx: u64 = u64::try_from(idx).unwrap();
95+
vtable_alloc.write_ptr_sized(ptr_size * idx, scalar)?;
96+
}
9197
}
9298

9399
M::after_static_mem_initialized(self, vtable, vtable_size)?;
@@ -99,16 +105,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
99105
}
100106

101107
/// Resolves the function at the specified slot in the provided
102-
/// vtable. An index of '0' corresponds to the first method
103-
/// declared in the trait of the provided vtable.
108+
/// vtable. Currently an index of '3' (`COMMON_VTABLE_ENTRIES.len()`)
109+
/// corresponds to the first method declared in the trait of the provided vtable.
104110
pub fn get_vtable_slot(
105111
&self,
106112
vtable: Scalar<M::PointerTag>,
107113
idx: u64,
108114
) -> InterpResult<'tcx, FnVal<'tcx, M::ExtraFnVal>> {
109115
let ptr_size = self.pointer_size();
110-
// Skip over the 'drop_ptr', 'size', and 'align' fields.
111-
let vtable_slot = vtable.ptr_offset(ptr_size * idx.checked_add(3).unwrap(), self)?;
116+
let vtable_slot = vtable.ptr_offset(ptr_size * idx, self)?;
112117
let vtable_slot = self
113118
.memory
114119
.get(vtable_slot, ptr_size, self.tcx.data_layout.pointer_align.abi)?
@@ -122,12 +127,21 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
122127
&self,
123128
vtable: Scalar<M::PointerTag>,
124129
) -> InterpResult<'tcx, (ty::Instance<'tcx>, Ty<'tcx>)> {
130+
let pointer_size = self.pointer_size();
125131
// We don't care about the pointee type; we just want a pointer.
126132
let vtable = self
127133
.memory
128-
.get(vtable, self.tcx.data_layout.pointer_size, self.tcx.data_layout.pointer_align.abi)?
134+
.get(
135+
vtable,
136+
pointer_size * u64::try_from(COMMON_VTABLE_ENTRIES.len()).unwrap(),
137+
self.tcx.data_layout.pointer_align.abi,
138+
)?
129139
.expect("cannot be a ZST");
130-
let drop_fn = vtable.read_ptr_sized(Size::ZERO)?.check_init()?;
140+
let drop_fn = vtable
141+
.read_ptr_sized(
142+
pointer_size * u64::try_from(COMMON_VTABLE_ENTRIES_DROPINPLACE).unwrap(),
143+
)?
144+
.check_init()?;
131145
// We *need* an instance here, no other kind of function value, to be able
132146
// to determine the type.
133147
let drop_instance = self.memory.get_fn(drop_fn)?.as_instance()?;
@@ -153,11 +167,19 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
153167
// the size, and the align (which we read below).
154168
let vtable = self
155169
.memory
156-
.get(vtable, 3 * pointer_size, self.tcx.data_layout.pointer_align.abi)?
170+
.get(
171+
vtable,
172+
pointer_size * u64::try_from(COMMON_VTABLE_ENTRIES.len()).unwrap(),
173+
self.tcx.data_layout.pointer_align.abi,
174+
)?
157175
.expect("cannot be a ZST");
158-
let size = vtable.read_ptr_sized(pointer_size)?.check_init()?;
176+
let size = vtable
177+
.read_ptr_sized(pointer_size * u64::try_from(COMMON_VTABLE_ENTRIES_SIZE).unwrap())?
178+
.check_init()?;
159179
let size = u64::try_from(self.force_bits(size, pointer_size)?).unwrap();
160-
let align = vtable.read_ptr_sized(pointer_size * 2)?.check_init()?;
180+
let align = vtable
181+
.read_ptr_sized(pointer_size * u64::try_from(COMMON_VTABLE_ENTRIES_ALIGN).unwrap())?
182+
.check_init()?;
161183
let align = u64::try_from(self.force_bits(align, pointer_size)?).unwrap();
162184
let align = Align::from_bytes(align).map_err(|e| err_ub!(InvalidVtableAlignment(e)))?;
163185

‎compiler/rustc_mir/src/monomorphize/collector.rs

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -196,7 +196,7 @@ use rustc_middle::mir::{self, Local, Location};
196196
use rustc_middle::ty::adjustment::{CustomCoerceUnsized, PointerCast};
197197
use rustc_middle::ty::print::with_no_trimmed_paths;
198198
use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts};
199-
use rustc_middle::ty::{self, GenericParamDefKind, Instance, Ty, TyCtxt, TypeFoldable};
199+
use rustc_middle::ty::{self, GenericParamDefKind, Instance, Ty, TyCtxt, TypeFoldable, VtblEntry};
200200
use rustc_middle::{middle::codegen_fn_attrs::CodegenFnAttrFlags, mir::visit::TyContext};
201201
use rustc_session::config::EntryFnType;
202202
use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
@@ -1091,21 +1091,22 @@ fn create_mono_items_for_vtable_methods<'tcx>(
10911091
assert!(!poly_trait_ref.has_escaping_bound_vars());
10921092

10931093
// Walk all methods of the trait, including those of its supertraits
1094-
let methods = tcx.vtable_methods(poly_trait_ref);
1095-
let methods = methods
1094+
let entries = tcx.vtable_entries(poly_trait_ref);
1095+
let methods = entries
10961096
.iter()
1097-
.cloned()
1098-
.filter_map(|method| method)
1099-
.map(|(def_id, substs)| {
1100-
ty::Instance::resolve_for_vtable(
1097+
.filter_map(|entry| match entry {
1098+
VtblEntry::MetadataDropInPlace
1099+
| VtblEntry::MetadataSize
1100+
| VtblEntry::MetadataAlign
1101+
| VtblEntry::Vacant => None,
1102+
VtblEntry::Method(def_id, substs) => ty::Instance::resolve_for_vtable(
11011103
tcx,
11021104
ty::ParamEnv::reveal_all(),
1103-
def_id,
1105+
*def_id,
11041106
substs,
11051107
)
1106-
.unwrap()
1108+
.filter(|instance| should_codegen_locally(tcx, instance)),
11071109
})
1108-
.filter(|&instance| should_codegen_locally(tcx, &instance))
11091110
.map(|item| create_fn_mono_item(tcx, item, source));
11101111
output.extend(methods);
11111112
}

‎compiler/rustc_trait_selection/src/traits/mod.rs

Lines changed: 82 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,8 @@ use rustc_hir::def_id::DefId;
3131
use rustc_middle::ty::fold::TypeFoldable;
3232
use rustc_middle::ty::subst::{InternalSubsts, SubstsRef};
3333
use rustc_middle::ty::{
34-
self, GenericParamDefKind, ParamEnv, ToPredicate, Ty, TyCtxt, WithConstness,
34+
self, GenericParamDefKind, ParamEnv, ToPredicate, Ty, TyCtxt, VtblEntry, WithConstness,
35+
COMMON_VTABLE_ENTRIES,
3536
};
3637
use rustc_span::Span;
3738

@@ -455,59 +456,89 @@ fn subst_and_check_impossible_predicates<'tcx>(
455456

456457
/// Given a trait `trait_ref`, iterates the vtable entries
457458
/// that come from `trait_ref`, including its supertraits.
458-
fn vtable_methods<'tcx>(
459+
fn vtable_entries<'tcx>(
459460
tcx: TyCtxt<'tcx>,
460461
trait_ref: ty::PolyTraitRef<'tcx>,
461-
) -> &'tcx [Option<(DefId, SubstsRef<'tcx>)>] {
462-
debug!("vtable_methods({:?})", trait_ref);
463-
464-
tcx.arena.alloc_from_iter(supertraits(tcx, trait_ref).flat_map(move |trait_ref| {
465-
let trait_methods = tcx
466-
.associated_items(trait_ref.def_id())
467-
.in_definition_order()
468-
.filter(|item| item.kind == ty::AssocKind::Fn);
469-
470-
// Now list each method's DefId and InternalSubsts (for within its trait).
471-
// If the method can never be called from this object, produce None.
472-
trait_methods.map(move |trait_method| {
473-
debug!("vtable_methods: trait_method={:?}", trait_method);
474-
let def_id = trait_method.def_id;
475-
476-
// Some methods cannot be called on an object; skip those.
477-
if !is_vtable_safe_method(tcx, trait_ref.def_id(), &trait_method) {
478-
debug!("vtable_methods: not vtable safe");
479-
return None;
480-
}
462+
) -> &'tcx [VtblEntry<'tcx>] {
463+
debug!("vtable_entries({:?})", trait_ref);
464+
465+
let entries = COMMON_VTABLE_ENTRIES.iter().cloned().chain(
466+
supertraits(tcx, trait_ref).flat_map(move |trait_ref| {
467+
let trait_methods = tcx
468+
.associated_items(trait_ref.def_id())
469+
.in_definition_order()
470+
.filter(|item| item.kind == ty::AssocKind::Fn);
471+
472+
// Now list each method's DefId and InternalSubsts (for within its trait).
473+
// If the method can never be called from this object, produce `Vacant`.
474+
trait_methods.map(move |trait_method| {
475+
debug!("vtable_entries: trait_method={:?}", trait_method);
476+
let def_id = trait_method.def_id;
477+
478+
// Some methods cannot be called on an object; skip those.
479+
if !is_vtable_safe_method(tcx, trait_ref.def_id(), &trait_method) {
480+
debug!("vtable_entries: not vtable safe");
481+
return VtblEntry::Vacant;
482+
}
481483

482-
// The method may have some early-bound lifetimes; add regions for those.
483-
let substs = trait_ref.map_bound(|trait_ref| {
484-
InternalSubsts::for_item(tcx, def_id, |param, _| match param.kind {
485-
GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),
486-
GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
487-
trait_ref.substs[param.index as usize]
488-
}
489-
})
490-
});
491-
492-
// The trait type may have higher-ranked lifetimes in it;
493-
// erase them if they appear, so that we get the type
494-
// at some particular call site.
495-
let substs =
496-
tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), substs);
497-
498-
// It's possible that the method relies on where-clauses that
499-
// do not hold for this particular set of type parameters.
500-
// Note that this method could then never be called, so we
501-
// do not want to try and codegen it, in that case (see #23435).
502-
let predicates = tcx.predicates_of(def_id).instantiate_own(tcx, substs);
503-
if impossible_predicates(tcx, predicates.predicates) {
504-
debug!("vtable_methods: predicates do not hold");
505-
return None;
506-
}
484+
// The method may have some early-bound lifetimes; add regions for those.
485+
let substs = trait_ref.map_bound(|trait_ref| {
486+
InternalSubsts::for_item(tcx, def_id, |param, _| match param.kind {
487+
GenericParamDefKind::Lifetime => tcx.lifetimes.re_erased.into(),
488+
GenericParamDefKind::Type { .. } | GenericParamDefKind::Const { .. } => {
489+
trait_ref.substs[param.index as usize]
490+
}
491+
})
492+
});
493+
494+
// The trait type may have higher-ranked lifetimes in it;
495+
// erase them if they appear, so that we get the type
496+
// at some particular call site.
497+
let substs =
498+
tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), substs);
499+
500+
// It's possible that the method relies on where-clauses that
501+
// do not hold for this particular set of type parameters.
502+
// Note that this method could then never be called, so we
503+
// do not want to try and codegen it, in that case (see #23435).
504+
let predicates = tcx.predicates_of(def_id).instantiate_own(tcx, substs);
505+
if impossible_predicates(tcx, predicates.predicates) {
506+
debug!("vtable_entries: predicates do not hold");
507+
return VtblEntry::Vacant;
508+
}
507509

508-
Some((def_id, substs))
509-
})
510-
}))
510+
VtblEntry::Method(def_id, substs)
511+
})
512+
}),
513+
);
514+
515+
tcx.arena.alloc_from_iter(entries)
516+
}
517+
518+
/// Find slot base for trait methods within vtable entries of another trait
519+
fn vtable_trait_first_method_offset<'tcx>(
520+
tcx: TyCtxt<'tcx>,
521+
key: (
522+
ty::PolyTraitRef<'tcx>, // trait_to_be_found
523+
ty::PolyTraitRef<'tcx>, // trait_owning_vtable
524+
),
525+
) -> usize {
526+
let (trait_to_be_found, trait_owning_vtable) = key;
527+
528+
let mut supertraits = util::supertraits(tcx, trait_owning_vtable);
529+
530+
// For each of the non-matching predicates that
531+
// we pass over, we sum up the set of number of vtable
532+
// entries, so that we can compute the offset for the selected
533+
// trait.
534+
let vtable_base = ty::COMMON_VTABLE_ENTRIES.len()
535+
+ supertraits
536+
.by_ref()
537+
.take_while(|t| *t != trait_to_be_found)
538+
.map(|t| util::count_own_vtable_entries(tcx, t))
539+
.sum::<usize>();
540+
541+
vtable_base
511542
}
512543

513544
/// Check whether a `ty` implements given trait(trait_def_id).
@@ -547,7 +578,7 @@ pub fn provide(providers: &mut ty::query::Providers) {
547578
specialization_graph_of: specialize::specialization_graph_provider,
548579
specializes: specialize::specializes,
549580
codegen_fulfill_obligation: codegen::codegen_fulfill_obligation,
550-
vtable_methods,
581+
vtable_entries,
551582
type_implements_trait,
552583
subst_and_check_impossible_predicates,
553584
mir_abstract_const: |tcx, def_id| {

‎compiler/rustc_trait_selection/src/traits/select/confirmation.rs

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -396,19 +396,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
396396
let mut nested = vec![];
397397

398398
let mut supertraits = util::supertraits(tcx, ty::Binder::dummy(object_trait_ref));
399-
400-
// For each of the non-matching predicates that
401-
// we pass over, we sum up the set of number of vtable
402-
// entries, so that we can compute the offset for the selected
403-
// trait.
404-
let vtable_base = supertraits
405-
.by_ref()
406-
.take(index)
407-
.map(|t| super::util::count_own_vtable_entries(tcx, t))
408-
.sum();
409-
410399
let unnormalized_upcast_trait_ref =
411-
supertraits.next().expect("supertraits iterator no longer has as many elements");
400+
supertraits.nth(index).expect("supertraits iterator no longer has as many elements");
412401

413402
let upcast_trait_ref = normalize_with_depth_to(
414403
self,
@@ -490,6 +479,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
490479
}
491480

492481
debug!(?nested, "object nested obligations");
482+
483+
let vtable_base = super::super::vtable_trait_first_method_offset(
484+
tcx,
485+
(unnormalized_upcast_trait_ref, ty::Binder::dummy(object_trait_ref)),
486+
);
487+
493488
Ok(ImplSourceObjectData { upcast_trait_ref, vtable_base, nested })
494489
}
495490

0 commit comments

Comments
 (0)
Please sign in to comment.