Skip to content

Commit cae6efc

Browse files
borsbors
committed
Auto merge of rust-lang#54183 - qnighy:by-value-object-safety, r=oli-obk
Implement by-value object safety This PR implements **by-value object safety**, which is part of unsized rvalues rust-lang#48055. That means, with `#![feature(unsized_locals)]`, you can call a method `fn foo(self, ...)` on trait objects. One aim of this is to enable `Box<FnOnce>` in the near future. The difficulty here is this: when constructing a vtable for a trait `Foo`, we can't just put the function `<T as Foo>::foo` into the table. If `T` is no larger than `usize`, `self` is usually passed directly. However, as the caller of the vtable doesn't know the concrete `Self` type, we want a variant of `<T as Foo>::foo` where `self` is always passed by reference. Therefore, when the compiler encounters such a method to be generated as a vtable entry, it produces a newly introduced instance called `InstanceDef::VtableShim(def_id)` (that wraps the original instance). the shim just derefs the receiver and calls the original method. We give different symbol names for the shims by appending `::{{vtable-shim}}` to the symbol path (and also adding vtable-shimness as an ingredient to the symbol hash). r? @eddyb
2 parents b3b8760 + 2f7ea4a commit cae6efc

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

46 files changed

+870
-171
lines changed

‎src/doc/unstable-book/src/language-features/unsized-locals.md

+2-4
Original file line numberDiff line numberDiff line change
@@ -101,9 +101,9 @@ fn main() {
101101
}
102102
```
103103

104-
And `Foo` will also be object-safe. However, this object-safety is not yet implemented.
104+
And `Foo` will also be object-safe.
105105

106-
```rust,ignore
106+
```rust
107107
#![feature(unsized_locals)]
108108

109109
trait Foo {
@@ -119,8 +119,6 @@ fn main () {
119119
}
120120
```
121121

122-
Unfortunately, this is not implemented yet.
123-
124122
One of the objectives of this feature is to allow `Box<dyn FnOnce>`, instead of `Box<dyn FnBox>` in the future. See [#28796] for details.
125123

126124
[#28796]: https://github.com/rust-lang/rust/issues/28796

‎src/librustc/ich/impls_ty.rs

+3
Original file line numberDiff line numberDiff line change
@@ -1007,6 +1007,9 @@ impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::InstanceDef<'gcx> {
10071007
ty::InstanceDef::Item(def_id) => {
10081008
def_id.hash_stable(hcx, hasher);
10091009
}
1010+
ty::InstanceDef::VtableShim(def_id) => {
1011+
def_id.hash_stable(hcx, hasher);
1012+
}
10101013
ty::InstanceDef::Intrinsic(def_id) => {
10111014
def_id.hash_stable(hcx, hasher);
10121015
}

‎src/librustc/ty/instance.rs

+96-1
Original file line numberDiff line numberDiff line change
@@ -8,13 +8,15 @@
88
// option. This file may not be copied, modified, or distributed
99
// except according to those terms.
1010

11+
use hir::Unsafety;
1112
use hir::def_id::DefId;
12-
use ty::{self, Ty, TypeFoldable, Substs, TyCtxt};
13+
use ty::{self, Ty, PolyFnSig, TypeFoldable, Substs, TyCtxt};
1314
use traits;
1415
use rustc_target::spec::abi::Abi;
1516
use util::ppaux;
1617

1718
use std::fmt;
19+
use std::iter;
1820

1921
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
2022
pub struct Instance<'tcx> {
@@ -27,6 +29,9 @@ pub enum InstanceDef<'tcx> {
2729
Item(DefId),
2830
Intrinsic(DefId),
2931

32+
/// `<T as Trait>::method` where `method` receives unsizeable `self: Self`.
33+
VtableShim(DefId),
34+
3035
/// \<fn() as FnTrait>::call_*
3136
/// def-id is FnTrait::call_*
3237
FnPtrShim(DefId, Ty<'tcx>),
@@ -56,13 +61,73 @@ impl<'a, 'tcx> Instance<'tcx> {
5661
&ty,
5762
)
5863
}
64+
65+
fn fn_sig_noadjust(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> PolyFnSig<'tcx> {
66+
let ty = self.ty(tcx);
67+
match ty.sty {
68+
ty::FnDef(..) |
69+
// Shims currently have type FnPtr. Not sure this should remain.
70+
ty::FnPtr(_) => ty.fn_sig(tcx),
71+
ty::Closure(def_id, substs) => {
72+
let sig = substs.closure_sig(def_id, tcx);
73+
74+
let env_ty = tcx.closure_env_ty(def_id, substs).unwrap();
75+
sig.map_bound(|sig| tcx.mk_fn_sig(
76+
iter::once(*env_ty.skip_binder()).chain(sig.inputs().iter().cloned()),
77+
sig.output(),
78+
sig.variadic,
79+
sig.unsafety,
80+
sig.abi
81+
))
82+
}
83+
ty::Generator(def_id, substs, _) => {
84+
let sig = substs.poly_sig(def_id, tcx);
85+
86+
let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv);
87+
let env_ty = tcx.mk_mut_ref(tcx.mk_region(env_region), ty);
88+
89+
sig.map_bound(|sig| {
90+
let state_did = tcx.lang_items().gen_state().unwrap();
91+
let state_adt_ref = tcx.adt_def(state_did);
92+
let state_substs = tcx.intern_substs(&[
93+
sig.yield_ty.into(),
94+
sig.return_ty.into(),
95+
]);
96+
let ret_ty = tcx.mk_adt(state_adt_ref, state_substs);
97+
98+
tcx.mk_fn_sig(iter::once(env_ty),
99+
ret_ty,
100+
false,
101+
Unsafety::Normal,
102+
Abi::Rust
103+
)
104+
})
105+
}
106+
_ => bug!("unexpected type {:?} in Instance::fn_sig_noadjust", ty)
107+
}
108+
}
109+
110+
pub fn fn_sig(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> ty::PolyFnSig<'tcx> {
111+
let mut fn_sig = self.fn_sig_noadjust(tcx);
112+
if let InstanceDef::VtableShim(..) = self.def {
113+
// Modify fn(self, ...) to fn(self: *mut Self, ...)
114+
fn_sig = fn_sig.map_bound(|mut fn_sig| {
115+
let mut inputs_and_output = fn_sig.inputs_and_output.to_vec();
116+
inputs_and_output[0] = tcx.mk_mut_ptr(inputs_and_output[0]);
117+
fn_sig.inputs_and_output = tcx.intern_type_list(&inputs_and_output);
118+
fn_sig
119+
});
120+
}
121+
fn_sig
122+
}
59123
}
60124

61125
impl<'tcx> InstanceDef<'tcx> {
62126
#[inline]
63127
pub fn def_id(&self) -> DefId {
64128
match *self {
65129
InstanceDef::Item(def_id) |
130+
InstanceDef::VtableShim(def_id) |
66131
InstanceDef::FnPtrShim(def_id, _) |
67132
InstanceDef::Virtual(def_id, _) |
68133
InstanceDef::Intrinsic(def_id, ) |
@@ -120,6 +185,9 @@ impl<'tcx> fmt::Display for Instance<'tcx> {
120185
ppaux::parameterized(f, self.substs, self.def_id(), &[])?;
121186
match self.def {
122187
InstanceDef::Item(_) => Ok(()),
188+
InstanceDef::VtableShim(_) => {
189+
write!(f, " - shim(vtable)")
190+
}
123191
InstanceDef::Intrinsic(_) => {
124192
write!(f, " - intrinsic")
125193
}
@@ -230,6 +298,25 @@ impl<'a, 'b, 'tcx> Instance<'tcx> {
230298
result
231299
}
232300

301+
pub fn resolve_for_vtable(tcx: TyCtxt<'a, 'tcx, 'tcx>,
302+
param_env: ty::ParamEnv<'tcx>,
303+
def_id: DefId,
304+
substs: &'tcx Substs<'tcx>) -> Option<Instance<'tcx>> {
305+
debug!("resolve(def_id={:?}, substs={:?})", def_id, substs);
306+
let fn_sig = tcx.fn_sig(def_id);
307+
let is_vtable_shim =
308+
fn_sig.inputs().skip_binder().len() > 0 && fn_sig.input(0).skip_binder().is_self();
309+
if is_vtable_shim {
310+
debug!(" => associated item with unsizeable self: Self");
311+
Some(Instance {
312+
def: InstanceDef::VtableShim(def_id),
313+
substs,
314+
})
315+
} else {
316+
Instance::resolve(tcx, param_env, def_id, substs)
317+
}
318+
}
319+
233320
pub fn resolve_closure(
234321
tcx: TyCtxt<'a, 'tcx, 'tcx>,
235322
def_id: DefId,
@@ -244,6 +331,14 @@ impl<'a, 'b, 'tcx> Instance<'tcx> {
244331
_ => Instance::new(def_id, substs.substs)
245332
}
246333
}
334+
335+
pub fn is_vtable_shim(&self) -> bool {
336+
if let InstanceDef::VtableShim(..) = self.def {
337+
true
338+
} else {
339+
false
340+
}
341+
}
247342
}
248343

249344
fn resolve_associated_item<'a, 'tcx>(

‎src/librustc/ty/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -2761,6 +2761,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
27612761
ty::InstanceDef::Item(did) => {
27622762
self.optimized_mir(did)
27632763
}
2764+
ty::InstanceDef::VtableShim(..) |
27642765
ty::InstanceDef::Intrinsic(..) |
27652766
ty::InstanceDef::FnPtrShim(..) |
27662767
ty::InstanceDef::Virtual(..) |

‎src/librustc/ty/structural_impls.rs

+4-1
Original file line numberDiff line numberDiff line change
@@ -467,6 +467,8 @@ impl<'a, 'tcx> Lift<'tcx> for ty::InstanceDef<'a> {
467467
match *self {
468468
ty::InstanceDef::Item(def_id) =>
469469
Some(ty::InstanceDef::Item(def_id)),
470+
ty::InstanceDef::VtableShim(def_id) =>
471+
Some(ty::InstanceDef::VtableShim(def_id)),
470472
ty::InstanceDef::Intrinsic(def_id) =>
471473
Some(ty::InstanceDef::Intrinsic(def_id)),
472474
ty::InstanceDef::FnPtrShim(def_id, ref ty) =>
@@ -647,6 +649,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
647649
substs: self.substs.fold_with(folder),
648650
def: match self.def {
649651
Item(did) => Item(did.fold_with(folder)),
652+
VtableShim(did) => VtableShim(did.fold_with(folder)),
650653
Intrinsic(did) => Intrinsic(did.fold_with(folder)),
651654
FnPtrShim(did, ty) => FnPtrShim(
652655
did.fold_with(folder),
@@ -675,7 +678,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> {
675678
use ty::InstanceDef::*;
676679
self.substs.visit_with(visitor) ||
677680
match self.def {
678-
Item(did) | Intrinsic(did) | Virtual(did, _) => {
681+
Item(did) | VtableShim(did) | Intrinsic(did) | Virtual(did, _) => {
679682
did.visit_with(visitor)
680683
},
681684
FnPtrShim(did, ty) | CloneShim(did, ty) => {

‎src/librustc_codegen_llvm/abi.rs

+10-11
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@
1111
use llvm::{self, AttributePlace};
1212
use base;
1313
use builder::{Builder, MemFlags};
14-
use common::{ty_fn_sig, C_usize};
14+
use common::C_usize;
1515
use context::CodegenCx;
1616
use mir::place::PlaceRef;
1717
use mir::operand::OperandValue;
@@ -283,8 +283,7 @@ pub trait FnTypeExt<'tcx> {
283283

284284
impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
285285
fn of_instance(cx: &CodegenCx<'ll, 'tcx>, instance: &ty::Instance<'tcx>) -> Self {
286-
let fn_ty = instance.ty(cx.tcx);
287-
let sig = ty_fn_sig(cx, fn_ty);
286+
let sig = instance.fn_sig(cx.tcx);
288287
let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
289288
FnType::new(cx, sig, &[])
290289
}
@@ -305,17 +304,17 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
305304
// Don't pass the vtable, it's not an argument of the virtual fn.
306305
// Instead, pass just the (thin pointer) first field of `*dyn Trait`.
307306
if arg_idx == Some(0) {
308-
if layout.is_unsized() {
309-
unimplemented!("by-value trait object is not \
310-
yet implemented in #![feature(unsized_locals)]");
311-
}
312307
// FIXME(eddyb) `layout.field(cx, 0)` is not enough because e.g.
313308
// `Box<dyn Trait>` has a few newtype wrappers around the raw
314309
// pointer, so we'd have to "dig down" to find `*dyn Trait`.
315-
let pointee = layout.ty.builtin_deref(true)
316-
.unwrap_or_else(|| {
317-
bug!("FnType::new_vtable: non-pointer self {:?}", layout)
318-
}).ty;
310+
let pointee = if layout.is_unsized() {
311+
layout.ty
312+
} else {
313+
layout.ty.builtin_deref(true)
314+
.unwrap_or_else(|| {
315+
bug!("FnType::new_vtable: non-pointer self {:?}", layout)
316+
}).ty
317+
};
319318
let fat_ptr_ty = cx.tcx.mk_mut_ptr(pointee);
320319
layout = cx.layout_of(fat_ptr_ty).field(cx, 0);
321320
}

‎src/librustc_codegen_llvm/base.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ use callee;
5656
use common::{C_bool, C_bytes_in_context, C_i32, C_usize};
5757
use rustc_mir::monomorphize::collector::{self, MonoItemCollectionMode};
5858
use rustc_mir::monomorphize::item::DefPathBasedNames;
59-
use common::{self, C_struct_in_context, C_array, val_ty};
59+
use common::{C_struct_in_context, C_array, val_ty};
6060
use consts;
6161
use context::CodegenCx;
6262
use debuginfo;
@@ -491,8 +491,7 @@ pub fn codegen_instance<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>, instance: Instance<'
491491
// release builds.
492492
info!("codegen_instance({})", instance);
493493

494-
let fn_ty = instance.ty(cx.tcx);
495-
let sig = common::ty_fn_sig(cx, fn_ty);
494+
let sig = instance.fn_sig(cx.tcx);
496495
let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
497496

498497
let lldecl = cx.instances.borrow().get(&instance).cloned().unwrap_or_else(||

‎src/librustc_codegen_llvm/callee.rs

+20-4
Original file line numberDiff line numberDiff line change
@@ -47,16 +47,16 @@ pub fn get_fn(
4747
assert!(!instance.substs.has_escaping_regions());
4848
assert!(!instance.substs.has_param_types());
4949

50-
let fn_ty = instance.ty(cx.tcx);
50+
let sig = instance.fn_sig(cx.tcx);
5151
if let Some(&llfn) = cx.instances.borrow().get(&instance) {
5252
return llfn;
5353
}
5454

5555
let sym = tcx.symbol_name(instance).as_str();
56-
debug!("get_fn({:?}: {:?}) => {}", instance, fn_ty, sym);
56+
debug!("get_fn({:?}: {:?}) => {}", instance, sig, sym);
5757

5858
// Create a fn pointer with the substituted signature.
59-
let fn_ptr_ty = tcx.mk_fn_ptr(common::ty_fn_sig(cx, fn_ty));
59+
let fn_ptr_ty = tcx.mk_fn_ptr(sig);
6060
let llptrty = cx.layout_of(fn_ptr_ty).llvm_type(cx);
6161

6262
let llfn = if let Some(llfn) = declare::get_declared_value(cx, &sym) {
@@ -91,7 +91,7 @@ pub fn get_fn(
9191
llfn
9292
}
9393
} else {
94-
let llfn = declare::declare_fn(cx, &sym, fn_ty);
94+
let llfn = declare::declare_fn(cx, &sym, sig);
9595
assert_eq!(common::val_ty(llfn), llptrty);
9696
debug!("get_fn: not casting pointer!");
9797

@@ -220,3 +220,19 @@ pub fn resolve_and_get_fn(
220220
).unwrap()
221221
)
222222
}
223+
224+
pub fn resolve_and_get_fn_for_vtable(
225+
cx: &CodegenCx<'ll, 'tcx>,
226+
def_id: DefId,
227+
substs: &'tcx Substs<'tcx>,
228+
) -> &'ll Value {
229+
get_fn(
230+
cx,
231+
ty::Instance::resolve_for_vtable(
232+
cx.tcx,
233+
ty::ParamEnv::reveal_all(),
234+
def_id,
235+
substs
236+
).unwrap()
237+
)
238+
}

‎src/librustc_codegen_llvm/common.rs

-51
Original file line numberDiff line numberDiff line change
@@ -30,9 +30,7 @@ use rustc::ty::layout::{HasDataLayout, LayoutOf};
3030
use rustc::hir;
3131

3232
use libc::{c_uint, c_char};
33-
use std::iter;
3433

35-
use rustc_target::spec::abi::Abi;
3634
use syntax::symbol::LocalInternedString;
3735
use syntax_pos::{Span, DUMMY_SP};
3836

@@ -404,52 +402,3 @@ pub fn shift_mask_val(
404402
_ => bug!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
405403
}
406404
}
407-
408-
pub fn ty_fn_sig<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>,
409-
ty: Ty<'tcx>)
410-
-> ty::PolyFnSig<'tcx>
411-
{
412-
match ty.sty {
413-
ty::FnDef(..) |
414-
// Shims currently have type FnPtr. Not sure this should remain.
415-
ty::FnPtr(_) => ty.fn_sig(cx.tcx),
416-
ty::Closure(def_id, substs) => {
417-
let tcx = cx.tcx;
418-
let sig = substs.closure_sig(def_id, tcx);
419-
420-
let env_ty = tcx.closure_env_ty(def_id, substs).unwrap();
421-
sig.map_bound(|sig| tcx.mk_fn_sig(
422-
iter::once(*env_ty.skip_binder()).chain(sig.inputs().iter().cloned()),
423-
sig.output(),
424-
sig.variadic,
425-
sig.unsafety,
426-
sig.abi
427-
))
428-
}
429-
ty::Generator(def_id, substs, _) => {
430-
let tcx = cx.tcx;
431-
let sig = substs.poly_sig(def_id, cx.tcx);
432-
433-
let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv);
434-
let env_ty = tcx.mk_mut_ref(tcx.mk_region(env_region), ty);
435-
436-
sig.map_bound(|sig| {
437-
let state_did = tcx.lang_items().gen_state().unwrap();
438-
let state_adt_ref = tcx.adt_def(state_did);
439-
let state_substs = tcx.intern_substs(&[
440-
sig.yield_ty.into(),
441-
sig.return_ty.into(),
442-
]);
443-
let ret_ty = tcx.mk_adt(state_adt_ref, state_substs);
444-
445-
tcx.mk_fn_sig(iter::once(env_ty),
446-
ret_ty,
447-
false,
448-
hir::Unsafety::Normal,
449-
Abi::Rust
450-
)
451-
})
452-
}
453-
_ => bug!("unexpected type {:?} to ty_fn_sig", ty)
454-
}
455-
}

0 commit comments

Comments
 (0)