More compile options

compiler/rustc_middle/src/ty/util.rs

@@ -1430,6 +1430,9 @@ impl<'tcx> Ty<'tcx> {
     /// Note that this method is used to check eligible types in unions.
     #[inline]
     pub fn needs_finalizer(self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> bool {
+        if tcx.sess.opts.cg.no_finalizer_elision {
+            return self.needs_drop(tcx, param_env);
+        }
         // Avoid querying in simple cases.
         match needs_drop_components(tcx, self) {
             Err(AlwaysRequiresDrop) => true,

compiler/rustc_mir_transform/src/check_finalizers.rs

@@ -73,6 +73,10 @@ impl<'tcx> FnInfo<'tcx> {
 
 impl<'tcx> MirPass<'tcx> for CheckFinalizers {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        if tcx.sess.opts.cg.no_finalizer_safety_analysis {
+            return;
+        }
+        trace!("Running FSA on {:?}", body.source);
         let param_env = tcx.param_env(body.source.def_id());
 
         if in_std_lib(tcx, body.source.def_id()) {

compiler/rustc_mir_transform/src/remove_elidable_drops.rs

@@ -8,6 +8,9 @@ pub struct RemoveElidableDrops;
 
 impl<'tcx> MirPass<'tcx> for RemoveElidableDrops {
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        if tcx.sess.opts.cg.no_premature_finalizer_prevention_opt {
+            return;
+        }
         trace!("Running RemoveElidableDrops on {:?}", body.source);
 
         let is_gc_crate = tcx

compiler/rustc_session/src/options.rs

@@ -1517,6 +1517,12 @@ options! {
         "perform LLVM link-time optimizations"),
     metadata: Vec<String> = (Vec::new(), parse_list, [TRACKED],
         "metadata to mangle symbol names with"),
+    no_finalizer_elision: bool = (false, parse_bool, [TRACKED],
+        "disable optimization to remove unnecessary finalizers"),
+    no_finalizer_safety_analysis: bool = (false, parse_bool, [TRACKED],
+        "disable checking of drop methods for GC soundness"),
+    no_premature_finalizer_prevention_opt: bool = (false, parse_bool, [TRACKED],
+        "disable optimization to remove unnecessary finalization barriers"),
     no_prepopulate_passes: bool = (false, parse_no_flag, [TRACKED],
         "give an empty list of passes to the pass manager"),
     no_redzone: Option<bool> = (None, parse_opt_bool, [TRACKED],

library/std/Cargo.toml

@@ -84,7 +84,6 @@ system-llvm-libunwind = ["unwind/system-llvm-libunwind"]
 
 # Alloy debug flags
 log-stats = ["alloc/log-stats"]
-finalizer-elision = []
 premature-finalizer-prevention = []
 
 # Make panics and failed asserts immediately abort without formatting any message

library/std/src/gc.rs

@@ -489,17 +489,8 @@ impl<T> Gc<T> {
     #[cfg(not(no_global_oom_handling))]
     unsafe fn new_internal(value: T) -> Self {
         #[cfg(not(bootstrap))]
-        {
-            #[cfg(feature = "finalizer-elision")]
-            let needs_finalizer = crate::mem::needs_finalizer::<T>();
-            #[cfg(not(feature = "finalizer-elision"))]
-            let needs_finalizer = crate::mem::needs_drop::<T>();
-
-            if !needs_finalizer {
-                return Self::from_inner(
-                    Box::leak(Box::new_in(GcBox { value }, GcAllocator)).into(),
-                );
-            }
+        if !crate::mem::needs_finalizer::<T>() {
+            return Self::from_inner(Box::leak(Box::new_in(GcBox { value }, GcAllocator)).into());
         }
 
         unsafe extern "C" fn finalizer_shim<T>(obj: *mut u8, _: *mut u8) {

library/sysroot/Cargo.toml

@@ -29,5 +29,4 @@ std_detect_env_override = ["std/std_detect_env_override"]
 
 # Alloy debug flags
 log-stats = ["std/log-stats"]
-finalizer-elision = ["std/finalizer-elision"]
 premature-finalizer-prevention = ["std/premature-finalizer-prevention"]

src/bootstrap/src/core/builder.rs

@@ -1517,6 +1517,17 @@ impl<'a> Builder<'a> {
             rustflags.arg("-Zunstable-options");
         }
 
+        // Alloy features
+        if stage != 0 && !self.config.finalizer_elision {
+            rustflags.arg("-Cno-finalizer-elision");
+        }
+        if stage != 0 && !self.config.finalizer_safety_analysis {
+            rustflags.arg("-Cno-finalizer-safety-analysis");
+        }
+        if stage != 0 && !self.config.premature_finalizer_prevention_optimize {
+            rustflags.arg("-Cno-premature-finalizer-prevention-opt");
+        }
+
         // Enable compile-time checking of `cfg` names, values and Cargo `features`.
         //
         // Note: `std`, `alloc` and `core` imports some dependencies by #[path] (like

src/bootstrap/src/core/config/config.rs

@@ -309,7 +309,9 @@ pub struct Config {
     // alloy debug features
     pub log_stats: bool, // support for LOG_ALLOY_STATS
     pub finalizer_elision: bool,
+    pub finalizer_safety_analysis: bool,
     pub premature_finalizer_prevention: bool,
+    pub premature_finalizer_prevention_optimize: bool,
 
     // misc
     pub low_priority: bool,
@@ -1143,7 +1145,9 @@ define_config! {
     struct Alloy {
         log_stats: Option<bool> = "log-stats",
         finalizer_elision: Option<bool> = "finalizer-elision",
+        finalizer_safety_analysis: Option<bool> = "finalizer-safety-analysis",
         premature_finalizer_prevention: Option<bool> = "premature-finalizer-prevention",
+        premature_finalizer_prevention_optimize: Option<bool> = "premature-finalizer-prevention-optimize",
     }
 }
 
@@ -1216,7 +1220,9 @@ impl Config {
             // alloy opts
             log_stats: false,
             finalizer_elision: true,
+            finalizer_safety_analysis: true,
             premature_finalizer_prevention: true,
+            premature_finalizer_prevention_optimize: true,
 
             ..Default::default()
         }
@@ -1771,11 +1777,22 @@ impl Config {
         config.rust_info = GitInfo::new(config.omit_git_hash, &config.src);
 
         if let Some(alloy) = toml.alloy {
-            let Alloy { log_stats, finalizer_elision, premature_finalizer_prevention } = alloy;
+            let Alloy {
+                log_stats,
+                finalizer_elision,
+                finalizer_safety_analysis,
+                premature_finalizer_prevention,
+                premature_finalizer_prevention_optimize,
+            } = alloy;
 
             set(&mut config.log_stats, log_stats);
             set(&mut config.finalizer_elision, finalizer_elision);
+            set(&mut config.finalizer_safety_analysis, finalizer_safety_analysis);
             set(&mut config.premature_finalizer_prevention, premature_finalizer_prevention);
+            set(
+                &mut config.premature_finalizer_prevention_optimize,
+                premature_finalizer_prevention_optimize,
+            );
         }
 
         if let Some(llvm) = toml.llvm {

src/bootstrap/src/lib.rs

@@ -753,9 +753,6 @@ impl Build {
         if self.config.log_stats {
             features.push_str(" log-stats");
         }
-        if self.config.finalizer_elision {
-            features.push_str(" finalizer-elision");
-        }
         if self.config.premature_finalizer_prevention {
             features.push_str(" premature-finalizer-prevention");
         }