Merge softdevteam#5

5: Automatically determine when finalizers can be omitted r=ltratt a=jacob-hughes

This PR introduces support for optimising away finalizers for Vecs whose element
types can be statically determined not to need dropping.

This requires the user to specify `Boehm` as the global allocator in their
crate, and the -Zgc-destination-propagation flag must be enabled.

Right now, this won't work recursively. In other words, if one were to create a
value with the following type:

    Gc<Vec<Vec<usize>>

A finalizer would still be registered unnecessarily.

This is because the MIR pass which determines which Vecs are allocated directly
in GC space currently looks only at the top-level element type inside a Vec.

    Gc<Vec<Vec<usize>>
        ^   ^
        |   |
        |   +---- No Finalizer
        +----- Finalizer

In order for both finalizers to be removed, one must implement
`ManageableContents` for `Vec<usize>`.


Co-authored-by: Jacob Hughes <jh@jakehughes.uk>

Author: bors[bot]

src/liballoc/gc.rs

@@ -119,7 +119,9 @@ impl<T> GcBox<T> {
 
         unsafe {
             ptr.copy_from_nonoverlapping(&gcbox, 1);
-            GcBox::register_finalizer(&mut *ptr);
+            if !Self::is_manageable_contents() && Self::needs_drop() {
+                GcBox::register_finalizer(&mut *ptr);
+            }
         }
 
         mem::forget(gcbox);
@@ -134,18 +136,8 @@ impl<T> GcBox<T> {
             NonNull::new_unchecked((base_ptr.add(1)) as *mut GcBox<MaybeUninit<T>>)
         }
     }
-}
-
-trait GcBoxExt {
-    fn register_finalizer(&mut self);
-}
 
-impl<T: ManageableContents> GcBoxExt for GcBox<Vec<T>> {
-    fn register_finalizer(&mut self) {}
-}
-
-impl<T> GcBoxExt for GcBox<T> {
-    default fn register_finalizer(&mut self) {
+    fn register_finalizer(&mut self) {
         unsafe extern "C" fn fshim<T>(obj: *mut c_void, _meta: *mut c_void) {
             ManuallyDrop::drop(&mut *(obj as *mut ManuallyDrop<T>));
         }
@@ -162,6 +154,38 @@ impl<T> GcBoxExt for GcBox<T> {
     }
 }
 
+trait IsManageableContents {
+    fn is_manageable_contents() -> bool;
+}
+
+impl<T> IsManageableContents for GcBox<T> {
+    default fn is_manageable_contents() -> bool {
+        false
+    }
+}
+
+impl<T: ManageableContents> IsManageableContents for GcBox<Vec<T>> {
+    fn is_manageable_contents() -> bool {
+        true
+    }
+}
+
+trait NeedsDrop {
+    fn needs_drop() -> bool;
+}
+
+impl<T> NeedsDrop for GcBox<T> {
+    default fn needs_drop() -> bool {
+        mem::needs_drop::<T>()
+    }
+}
+
+impl<T> NeedsDrop for GcBox<Vec<T>> {
+    fn needs_drop() -> bool {
+        mem::needs_drop::<T>()
+    }
+}
+
 impl<T> GcBox<MaybeUninit<T>> {
     unsafe fn assume_init(&mut self) -> NonNull<GcBox<T>> {
         // With T now considered initialized, we must make sure that if GcBox<T>

src/librustc_mir/transform/preallocate_gc_contents.rs

@@ -17,8 +17,11 @@ pub struct GcPreallocator;
 
 impl<'tcx> MirPass<'tcx> for GcPreallocator {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, source: MirSource<'tcx>, body: &mut BodyAndCache<'tcx>) {
-        let param_env = tcx.param_env(source.def_id()).with_reveal_all();
+        if !tcx.sess.opts.debugging_opts.gc_destination_propagation {
+            return;
+        }
 
+        let param_env = tcx.param_env(source.def_id()).with_reveal_all();
         GcPatcher { tcx, source, param_env }.run_pass(body);
     }
 }
@@ -46,11 +49,7 @@ impl GcPatcher<'tcx> {
                     let name = self.tcx.def_path_str(callee_def_id);
                     let new_term = match name.as_str() {
                         VEC_WITH_CAPACITY => {
-                            if !ty_impls_manageable_contents(
-                                substs.type_at(0),
-                                self.tcx,
-                                self.param_env,
-                            ) {
+                            if elem_ty_must_drop(substs.type_at(0), self.tcx, self.param_env) {
                                 continue;
                             }
                             let new_callee = self.tcx.lang_items().vec_with_capacity_fn().unwrap();
@@ -65,11 +64,7 @@ impl GcPatcher<'tcx> {
                             }
                         }
                         VEC_PUSH => {
-                            if !ty_impls_manageable_contents(
-                                substs.type_at(0),
-                                self.tcx,
-                                self.param_env,
-                            ) {
+                            if elem_ty_must_drop(substs.type_at(0), self.tcx, self.param_env) {
                                 continue;
                             }
                             let new_callee = self.tcx.lang_items().vec_push_gc_fn().unwrap();
@@ -93,20 +88,20 @@ impl GcPatcher<'tcx> {
     }
 }
 
-fn ty_impls_manageable_contents<'tcx>(
-    ty: Ty<'tcx>,
-    tcx: TyCtxt<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-) -> bool {
-    let prealloc_trait_id = tcx.lang_items().manageable_contents_trait().unwrap();
-    let obligation = predicate_for_trait_def(
-        tcx,
-        param_env,
-        traits::ObligationCause::dummy(),
-        prealloc_trait_id,
-        0,
-        ty,
-        &[],
-    );
-    tcx.infer_ctxt().enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
+fn elem_ty_must_drop<'tcx>(ty: Ty<'tcx>, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> bool {
+    if !ty.needs_drop(tcx, param_env) {
+        return false;
+    } else {
+        let prealloc_trait_id = tcx.lang_items().manageable_contents_trait().unwrap();
+        let obligation = predicate_for_trait_def(
+            tcx,
+            param_env,
+            traits::ObligationCause::dummy(),
+            prealloc_trait_id,
+            0,
+            ty,
+            &[],
+        );
+        tcx.infer_ctxt().enter(|infcx| infcx.predicate_must_hold_modulo_regions(&obligation))
+    }
 }

src/librustc_session/options.rs

@@ -973,4 +973,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "link native libraries in the linker invocation (default: yes)"),
     src_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
         "hash algorithm of source files in debug info (`md5`, or `sha1`)"),
+    gc_destination_propagation: bool = (false, parse_bool, [TRACKED],
+        "only enable this if Boehm is the global allocator"),
 }