Fix to not do LTO when LTO is not enabled in gcc

Author: antoyo

src/back/lto.rs

@@ -642,6 +642,7 @@ pub fn optimize_thin_module(
         GccContext {
             context,
             lto_mode,
+            lto_supported: false, // TODO(antoyo): check if this is correct to use this value.
             // TODO(antoyo): use the correct relocation model here.
             relocation_model: RelocModel::Pic,
             temp_dir: None,

src/back/write.rs

@@ -25,6 +25,7 @@ pub(crate) fn codegen(
         let context = &module.module_llvm.context;
 
         let lto_mode = module.module_llvm.lto_mode;
+        let lto_supported = module.module_llvm.lto_supported;
 
         let bc_out = cgcx.output_filenames.temp_path_for_cgu(
             OutputType::Bitcode,
@@ -51,14 +52,17 @@ pub(crate) fn codegen(
                 );
             }*/
 
+            // TODO: only emit if libgccjit is compiled with LTO enabled?
             if config.emit_bc || config.emit_obj == EmitObj::Bitcode {
                 let _timer = cgcx
                     .prof
                     .generic_activity_with_arg("GCC_module_codegen_emit_bitcode", &*module.name);
-                context.add_command_line_option("-flto=auto");
-                context.add_command_line_option("-flto-partition=one");
-                // TODO(antoyo): remove since we don't want fat objects when it is for Bitcode only.
-                context.add_command_line_option("-ffat-lto-objects");
+                if lto_supported {
+                    context.add_command_line_option("-flto=auto");
+                    context.add_command_line_option("-flto-partition=one");
+                    // TODO(antoyo): remove since we don't want fat objects when it is for Bitcode only.
+                    context.add_command_line_option("-ffat-lto-objects");
+                }
                 context
                     .compile_to_file(OutputKind::ObjectFile, bc_out.to_str().expect("path to str"));
             }
@@ -67,12 +71,14 @@ pub(crate) fn codegen(
                 let _timer = cgcx
                     .prof
                     .generic_activity_with_arg("GCC_module_codegen_embed_bitcode", &*module.name);
-                // TODO(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
-                //embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
+                if lto_supported {
+                    // TODO(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
+                    //embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
 
-                context.add_command_line_option("-flto=auto");
-                context.add_command_line_option("-flto-partition=one");
-                context.add_command_line_option("-ffat-lto-objects");
+                    context.add_command_line_option("-flto=auto");
+                    context.add_command_line_option("-flto-partition=one");
+                    context.add_command_line_option("-ffat-lto-objects");
+                }
                 // TODO(antoyo): Send -plugin/usr/lib/gcc/x86_64-pc-linux-gnu/11.1.0/liblto_plugin.so to linker (this should be done when specifying the appropriate rustc cli argument).
                 context
                     .compile_to_file(OutputKind::ObjectFile, bc_out.to_str().expect("path to str"));

src/base.rs

@@ -74,6 +74,7 @@ pub fn compile_codegen_unit(
     tcx: TyCtxt<'_>,
     cgu_name: Symbol,
     target_info: LockedTargetInfo,
+    lto_supported: bool,
 ) -> (ModuleCodegen<GccContext>, u64) {
     let prof_timer = tcx.prof.generic_activity("codegen_module");
     let start_time = Instant::now();
@@ -82,7 +83,7 @@ pub fn compile_codegen_unit(
     let (module, _) = tcx.dep_graph.with_task(
         dep_node,
         tcx,
-        (cgu_name, target_info),
+        (cgu_name, target_info, lto_supported),
         module_codegen,
         Some(dep_graph::hash_result),
     );
@@ -95,7 +96,7 @@ pub fn compile_codegen_unit(
 
     fn module_codegen(
         tcx: TyCtxt<'_>,
-        (cgu_name, target_info): (Symbol, LockedTargetInfo),
+        (cgu_name, target_info, lto_supported): (Symbol, LockedTargetInfo, bool),
     ) -> ModuleCodegen<GccContext> {
         let cgu = tcx.codegen_unit(cgu_name);
         // Instantiate monomorphizations without filling out definitions yet...
@@ -247,6 +248,7 @@ pub fn compile_codegen_unit(
             GccContext {
                 context: Arc::new(SyncContext::new(context)),
                 relocation_model: tcx.sess.relocation_model(),
+                lto_supported,
                 lto_mode: LtoMode::None,
                 temp_dir: None,
             },

src/lib.rs

@@ -85,10 +85,7 @@ mod type_of;
 use std::any::Any;
 use std::fmt::Debug;
 use std::ops::Deref;
-#[cfg(not(feature = "master"))]
-use std::sync::atomic::AtomicBool;
-#[cfg(not(feature = "master"))]
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
 use back::lto::{ThinBuffer, ThinData};
@@ -182,6 +179,7 @@ impl LockedTargetInfo {
 #[derive(Clone)]
 pub struct GccCodegenBackend {
     target_info: LockedTargetInfo,
+    lto_supported: Arc<AtomicBool>,
 }
 
 impl CodegenBackend for GccCodegenBackend {
@@ -203,6 +201,29 @@ impl CodegenBackend for GccCodegenBackend {
             **self.target_info.info.lock().expect("lock") = context.get_target_info();
         }
 
+        // TODO: try the LTO frontend and check if it errors out. If so, do not embed the bitcode.
+        {
+            let temp_dir = TempDir::new().expect("cannot create temporary directory");
+            let temp_file = temp_dir.into_path().join("result.asm");
+            let context = Context::default();
+            let object_file_path = temp_file.to_str().expect("path to str");
+            context.compile_to_file(gccjit::OutputKind::ObjectFile, object_file_path);
+
+            //let temp_dir = TempDir::new().expect("cannot create temporary directory");
+            //let temp_file = temp_dir.into_path().join("result.asm");
+            let check_context = Context::default();
+            check_context.add_driver_option("-x");
+            check_context.add_driver_option("lto");
+            check_context.add_driver_option(object_file_path);
+            check_context.set_print_errors_to_stderr(false);
+            //context.compile_to_file(gccjit::OutputKind::ObjectFile, temp_file.to_str().expect("path to str"));
+            // FIXME: compile gives the error as expected, but compile_to_file doesn't.
+            check_context.compile();
+            let error = check_context.get_last_error();
+            let lto_supported = error == Ok(None);
+            self.lto_supported.store(lto_supported, Ordering::SeqCst);
+        }
+
         #[cfg(feature = "master")]
         gccjit::set_global_personality_function_name(b"rust_eh_personality\0");
 
@@ -288,6 +309,7 @@ impl ExtraBackendMethods for GccCodegenBackend {
             context: Arc::new(SyncContext::new(new_context(tcx))),
             relocation_model: tcx.sess.relocation_model(),
             lto_mode: LtoMode::None,
+            lto_supported: false,
             temp_dir: None,
         };
 
@@ -302,7 +324,12 @@ impl ExtraBackendMethods for GccCodegenBackend {
         tcx: TyCtxt<'_>,
         cgu_name: Symbol,
     ) -> (ModuleCodegen<Self::Module>, u64) {
-        base::compile_codegen_unit(tcx, cgu_name, self.target_info.clone())
+        base::compile_codegen_unit(
+            tcx,
+            cgu_name,
+            self.target_info.clone(),
+            self.lto_supported.load(Ordering::SeqCst),
+        )
     }
 
     fn target_machine_factory(
@@ -329,6 +356,7 @@ pub struct GccContext {
     /// LTO.
     relocation_model: RelocModel,
     lto_mode: LtoMode,
+    lto_supported: bool,
     // Temporary directory used by LTO. We keep it here so that it's not removed before linking.
     temp_dir: Option<TempDir>,
 }
@@ -466,7 +494,10 @@ pub fn __rustc_codegen_backend() -> Box<dyn CodegenBackend> {
         supports_128bit_integers: AtomicBool::new(false),
     })));
 
-    Box::new(GccCodegenBackend { target_info: LockedTargetInfo { info } })
+    Box::new(GccCodegenBackend {
+        lto_supported: Arc::new(AtomicBool::new(false)),
+        target_info: LockedTargetInfo { info },
+    })
 }
 
 fn to_gcc_opt_level(optlevel: Option<OptLevel>) -> OptimizationLevel {