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

Author: antoyo

src/back/lto.rs

@@ -281,6 +281,7 @@ fn fat_lto(
             let config = cgcx.config(module.kind);
             // NOTE: we need to set the optimization level here in order for LTO to do its job.
             context.set_optimization_level(to_gcc_opt_level(config.opt_level));
+            println!("1. Using LTO");
             context.add_command_line_option("-flto=auto");
             context.add_command_line_option("-flto-partition=one");
             context.compile_to_file(OutputKind::ObjectFile, path);
@@ -641,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,18 @@ 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 {
+                    println!("2. Using LTO: {}", 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");
+                }
                 context
                     .compile_to_file(OutputKind::ObjectFile, bc_out.to_str().expect("path to str"));
             }
@@ -70,6 +75,7 @@ pub(crate) fn codegen(
                 // TODO(antoyo): maybe we should call embed_bitcode to have the proper iOS fixes?
                 //embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
 
+                println!("3. Using LTO");
                 context.add_command_line_option("-flto=auto");
                 context.add_command_line_option("-flto-partition=one");
                 context.add_command_line_option("-ffat-lto-objects");
@@ -129,6 +135,7 @@ pub(crate) fn codegen(
                     // We need to check if we're doing LTO since this code is also used for the
                     // dummy ThinLTO implementation to combine the object files.
                     if fat_lto {
+                        println!("4. Using LTO");
                         context.add_command_line_option("-flto=auto");
                         context.add_command_line_option("-flto-partition=one");
 
@@ -170,6 +177,7 @@ pub(crate) fn codegen(
                         // NOTE: these two options are needed to invoke LTO to produce an object file.
                         // We need to initiate a second compilation because the arguments "-x lto"
                         // needs to be at the very beginning.
+                        println!("Using LTO frontend");
                         context.add_driver_option("-x");
                         context.add_driver_option("lto");
                         add_pic_option(&context, module.module_llvm.relocation_model);

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...
@@ -242,6 +243,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

@@ -84,10 +84,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};
@@ -181,6 +178,7 @@ impl LockedTargetInfo {
 #[derive(Clone)]
 pub struct GccCodegenBackend {
     target_info: LockedTargetInfo,
+    lto_supported: Arc<AtomicBool>,
 }
 
 impl CodegenBackend for GccCodegenBackend {
@@ -202,6 +200,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");
 
@@ -298,6 +319,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,
         };
 
@@ -312,7 +334,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(
@@ -339,6 +366,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>,
 }
@@ -475,7 +503,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 {