WIP: Working state for having the test program to compile with LTO

This requires having the following line commented in libgccjit:

ADD_ARG ("-fno-use-linker-plugin");

And this also requires having the sysroot compiled with fat LTO.

Author: antoyo

src/back/lto.rs

@@ -280,6 +280,7 @@ fn fat_lto(
             context.set_optimization_level(to_gcc_opt_level(config.opt_level));
             context.add_command_line_option("-flto=auto");
             context.add_command_line_option("-flto-partition=one");
+            //context.add_command_line_option("-fno-use-linker-plugin");
             context.compile_to_file(OutputKind::ObjectFile, path);
             let buffer = ModuleBuffer::new(PathBuf::from(path));
             let llmod_id = CString::new(&module.name[..]).unwrap();
@@ -314,6 +315,20 @@ fn fat_lto(
         save_temp_bitcode(cgcx, &module, "lto.input");
 
         let int_type = module.module_llvm.context.new_type::<i32>();
+        /*
+         * TODO: Preserve the symbols via a linker script instead?
+         * TODO TODO: use the symbols in inline asm to keep them?
+         * ===> This seems to work and is easy.
+         *
+         * FIXME: main is not genarated in GIMPLE IR; it is generated as asm.
+         * ===> seems now fixed since I commented this line in libgccjit:
+         * ADD_ARG ("-fno-use-linker-plugin");
+         * FIXME: it seems "make install" doesn't copy liblto_plugin.so.
+         * ===> seems now fixed after a rebuild.
+         *
+         * TODO TODO TODO: add -fno-use-linker-plugin because:
+         * This option is enabled by default when LTO support in GCC is enabled and GCC was configured for use with a linker supporting plugins (GNU ld 2.21 or newer or gold).
+         */
         for symbol in symbols_below_threshold {
             println!("*** Keeping symbol: {}", symbol);
             module.module_llvm.context.new_global(None, GlobalKind::Imported, int_type, symbol);
@@ -322,17 +337,20 @@ fn fat_lto(
         }
         let void_type = module.module_llvm.context.new_type::<()>();
         let main_func = module.module_llvm.context.new_function(None, FunctionType::Extern, void_type, &[], "main", false);
-        main_func.add_attribute(FnAttribute::Used);
+        //main_func.add_attribute(FnAttribute::Used);
 
         // NOTE: look at the code from 64b30d344ce54f8ee496cb3590b4c7cf3cb30447 to see previous
         // attemps.
         let func = module.module_llvm.context.new_function(None, FunctionType::Exported, void_type, &[], "__my_call_main", false);
-        func.add_attribute(FnAttribute::AlwaysInline);
-        func.add_attribute(FnAttribute::Inline);
+        //func.add_attribute(FnAttribute::AlwaysInline);
+        //func.add_attribute(FnAttribute::Inline);
         func.add_attribute(FnAttribute::Used);
         let block = func.new_block("start");
-        let call = module.module_llvm.context.new_call(None, main_func, &[]);
-        block.add_eval(None, call);
+        let main_func_address = main_func.get_address(None);
+        /*let asm = block.add_extended_asm(None, "");
+        asm.add_input_operand(None, "X", main_func_address);*/
+        //let call = module.module_llvm.context.new_call(None, main_func, &[]);
+        //block.add_eval(None, call);
         block.end_with_void_return(None);
 
         // Internalize everything below threshold to help strip out more modules and such.

src/back/write.rs

@@ -57,13 +57,17 @@ pub(crate) unsafe fn codegen(
                     );
                 }*/
 
+                // TODO: make this work to make it easier to debug GCC-related issue within
+                // rustc_codegen_gcc:
+                //context.add_driver_option("-wrapper gdb,--args");
                 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");
+                    //context.add_command_line_option("-fno-use-linker-plugin");
                     // 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(
@@ -82,6 +86,7 @@ pub(crate) unsafe fn codegen(
 
                     context.add_command_line_option("-flto=auto");
                     context.add_command_line_option("-flto-partition=one");
+                    //context.add_command_line_option("-fno-use-linker-plugin");
                     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(
@@ -169,6 +174,14 @@ pub(crate) unsafe fn codegen(
                     if fat_lto {
                         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("-fno-use-linker-plugin");
+
+                        // FIXME FIXME FIXME:
+                        // /usr/bin/ld: warning: incremental linking of LTO and non-LTO objects; using -flinker-output=nolto-rel which will bypass whole program optimization
+                        // ====> So I'm probably missing -flto somewhere.
+
+                        println!("**** Adding -flto to {:?}", obj_out.to_str().expect("path to str"));
 
                         // FIXME: the problem is probably that the code is only in GIMPLE IR while
                         // we would want to get the optimized asm done from LTO.
@@ -180,6 +193,7 @@ pub(crate) unsafe fn codegen(
                     // NOTE: we need -nostdlib, otherwise, we get the following error:
                     // /usr/bin/ld: cannot find -lgcc_s: No such file or directory
                     context.add_driver_option("-nostdlib");
+                    //context.add_driver_option("-v");
 
                     let path = obj_out.to_str().expect("path to str");
 
@@ -193,9 +207,12 @@ pub(crate) unsafe fn codegen(
                         //
                         // This option is to mute it to make the UI tests pass with LTO enabled.
                         context.add_driver_option("-Wno-lto-type-mismatch");
+                        //context.add_driver_option("-v");
                         // NOTE: this doesn't actually generate an executable. With the above
                         // flags, it combines the .o files together in another .o.
+                        println!("Lto path: {:?}", lto_path);
                         context.compile_to_file(OutputKind::Executable, &lto_path);
+                        println!("****************************************************************************************************");
 
                         let context = Context::default();
                         if cgcx.target_arch == "x86" || cgcx.target_arch == "x86_64" {
@@ -209,6 +226,7 @@ pub(crate) unsafe fn codegen(
                         // needs to be at the very beginning.
                         context.add_driver_option("-x");
                         context.add_driver_option("lto");
+                        //context.add_driver_option("-v");
                         add_pic_option(&context, module.module_llvm.relocation_model);
                         context.add_driver_option(lto_path);
                         // TODO TODO: inspect the resulting file to see if it contains the GIMPLE IR or

src/declare.rs

@@ -189,6 +189,10 @@ fn declare_raw_fn<'gcc>(
             .collect();
         #[cfg(not(feature = "master"))]
         let name = &mangle_name(name);
+        if name == "main" {
+            //cx.context.add_driver_option("-v");
+            println!("**** Main function in {}", cx.codegen_unit.name());
+        }
         let func =
             cx.context.new_function(None, cx.linkage.get(), return_type, &params, name, variadic);
         #[cfg(feature = "master")]