Sync rustc_codegen_gcc subtree

compiler/rustc_codegen_gcc/.github/workflows/release.yml

@@ -62,7 +62,7 @@ jobs:
     - name: Build
       run: |
         ./y.sh prepare --only-libcore
-        EMBED_LTO_BITCODE=1 ./y.sh build --sysroot --release --release-sysroot
+        ./y.sh build --sysroot --release --release-sysroot
         ./y.sh test --cargo-tests
         ./y.sh clean all
 
@@ -72,26 +72,36 @@ jobs:
         git config --global user.name "User"
         ./y.sh prepare
 
-    - name: Add more failing tests because of undefined symbol errors (FIXME)
-      run: cat tests/failing-lto-tests.txt >> tests/failing-ui-tests.txt
-
     - name: Run tests
       run: |
         # FIXME(antoyo): we cannot enable LTO for stdarch tests currently because of some failing LTO tests using proc-macros.
-        # FIXME(antoyo): this should probably not be needed since we embed the LTO bitcode.
-        printf '[profile.release]\nlto = "fat"\n' >> build/build_sysroot/sysroot_src/library/Cargo.toml
-        EMBED_LTO_BITCODE=1 ./y.sh test --release --clean --release-sysroot --build-sysroot --keep-lto-tests ${{ matrix.commands }}
+        CG_RUSTFLAGS="-Cembed-bitcode=yes" ./y.sh test --release --clean --release-sysroot --build-sysroot --keep-lto-tests ${{ matrix.commands }}
 
-    - name: Run y.sh cargo build
+    - name: LTO test
       run: |
-        EMBED_LTO_BITCODE=1 CHANNEL="release" ./y.sh cargo build --release --manifest-path tests/hello-world/Cargo.toml
+        CHANNEL="release" ./y.sh cargo build --release --manifest-path tests/hello-world/Cargo.toml
         call_found=$(objdump -dj .text tests/hello-world/target/release/hello_world | grep -c "call .*mylib.*my_func" ) ||:
         if [ $call_found -gt 0 ]; then
           echo "ERROR: call my_func found in asm"
           echo "Test is done with LTO enabled, hence inlining should occur across crates"
           exit 1
         fi
 
+    - name: Cross-language LTO test
+      run: |
+        pushd tests/cross_lang_lto
+        gcc -c -flto add.c -masm=intel -fPIC -O3
+        ar rcs libadd.a add.o
+        popd
+
+        CHANNEL="release" CG_RUSTFLAGS="-L native=. -Clinker-plugin-lto -Clinker=gcc" ./y.sh cargo build --release --manifest-path tests/cross_lang_lto/Cargo.toml
+        call_found=$(objdump -dj .text tests/cross_lang_lto/target/release/cross_lang_lto | grep -c "call .*my_add" ) ||:
+        if [ $call_found -gt 0 ]; then
+          echo "ERROR: call my_add found in asm"
+          echo "Test is done with cross-language LTO enabled, hence inlining should occur across object files"
+          exit 1
+        fi
+
   # Summary job for the merge queue.
   # ALL THE PREVIOUS JOBS NEED TO BE ADDED TO THE `needs` SECTION OF THIS JOB!
   success_release:

compiler/rustc_codegen_gcc/.github/workflows/stdarch.yml

@@ -41,7 +41,7 @@ jobs:
     # TODO: remove when we have binutils version 2.43 in the repo.
     - name: Install more recent binutils
       run: |
-        echo "deb http://archive.ubuntu.com/ubuntu oracular main universe" | sudo tee /etc/apt/sources.list.d/oracular-copies.list
+        echo "deb http://archive.ubuntu.com/ubuntu plucky main universe" | sudo tee /etc/apt/sources.list.d/plucky-copies.list
         sudo apt-get update
         sudo apt-get install binutils
 

compiler/rustc_codegen_gcc/Cargo.lock

@@ -56,18 +56,18 @@ dependencies = [
 
 [[package]]
 name = "gccjit"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0e310ef75f396cd11b2443b353d55376656ca92c13cba36f92b7aff346ac1a"
+checksum = "60362e038e71e4bdc1a5b23fb45e1aba587b5947fe0db58f4871d95608f89eca"
 dependencies = [
  "gccjit_sys",
 ]
 
 [[package]]
 name = "gccjit_sys"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ed7572b30cd32430294dde6fb70822d58e67c6846a548647e8739776a0125b"
+checksum = "ddd542c8414e122217551c6af6b7d33acf51a227aee85276f218c087525e01bb"
 dependencies = [
  "libc",
 ]

compiler/rustc_codegen_gcc/Cargo.toml

@@ -24,7 +24,7 @@ default = ["master"]
 [dependencies]
 object = { version = "0.37.0", default-features = false, features = ["std", "read"] }
 tempfile = "3.20"
-gccjit = "2.8"
+gccjit = "2.10"
 #gccjit = { git = "https://github.com/rust-lang/gccjit.rs" }
 
 # Local copy.

compiler/rustc_codegen_gcc/Readme.md

@@ -70,11 +70,17 @@ $ ../gcc/configure \
 $ make -j4 # You can replace `4` with another number depending on how many cores you have.
 ```
 
-If you want to run libgccjit tests, you will need to also enable the C++ language in the `configure`:
+If you want to run libgccjit tests, you will need to
+* Enable the C++ language in the `configure` step:
 
 ```bash
 --enable-languages=jit,c++
 ```
+* Install [dejagnu](https://www.gnu.org/software/dejagnu/#downloading) to run the tests:
+
+```bash
+$ sudo apt install dejagnu
+```
 
 Then to run libgccjit tests:
 
@@ -135,16 +141,6 @@ $ CHANNEL="release" $CG_GCCJIT_DIR/y.sh cargo run
 
 If you compiled cg_gccjit in debug mode (aka you didn't pass `--release` to `./y.sh test`) you should use `CHANNEL="debug"` instead or omit `CHANNEL="release"` completely.
 
-### LTO
-
-To use LTO, you need to set the variable `EMBED_LTO_BITCODE=1` in addition to setting `lto = "fat"` in the `Cargo.toml`.
-
-Failing to set `EMBED_LTO_BITCODE` will give you the following error:
-
-```
-error: failed to copy bitcode to object file: No such file or directory (os error 2)
-```
-
 ### Rustc
 
 If you want to run `rustc` directly, you can do so with:

compiler/rustc_codegen_gcc/build_system/src/build.rs

@@ -149,6 +149,9 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
 
     // Copy files to sysroot
     let sysroot_path = start_dir.join(format!("sysroot/lib/rustlib/{}/lib/", config.target_triple));
+    // To avoid errors like "multiple candidates for `rmeta` dependency `core` found", we clean the
+    // sysroot directory before copying the sysroot build artifacts.
+    let _ = fs::remove_dir_all(&sysroot_path);
     create_dir(&sysroot_path)?;
     let mut copier = |dir_to_copy: &Path| {
         // FIXME: should not use shell command!

compiler/rustc_codegen_gcc/build_system/src/clean.rs

@@ -69,8 +69,13 @@ fn clean_all() -> Result<(), String> {
 }
 
 fn clean_ui_tests() -> Result<(), String> {
-    let path = Path::new(crate::BUILD_DIR).join("rust/build/x86_64-unknown-linux-gnu/test/ui/");
-    run_command(&[&"find", &path, &"-name", &"stamp", &"-delete"], None)?;
+    let directories = ["run-make", "run-make-cargo", "ui"];
+    for directory in directories {
+        let path = Path::new(crate::BUILD_DIR)
+            .join("rust/build/x86_64-unknown-linux-gnu/test/")
+            .join(directory);
+        run_command(&[&"find", &path, &"-name", &"stamp", &"-delete"], None)?;
+    }
     Ok(())
 }
 

compiler/rustc_codegen_gcc/build_system/src/prepare.rs

@@ -1,12 +1,49 @@
+use std::ffi::OsStr;
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::process::Output;
 
 use crate::rustc_info::get_rustc_path;
 use crate::utils::{
     cargo_install, create_dir, get_sysroot_dir, git_clone_root_dir, remove_file, run_command,
     run_command_with_output, walk_dir,
 };
 
+// This is needed on systems where nothing is configured.
+// git really needs something here, or it will fail.
+// Even using --author is not enough.
+const GIT_CMD: [&dyn AsRef<OsStr>; 9] = [
+    &"git",
+    &"-c",
+    &"user.name=None",
+    &"-c",
+    &"user.email=none@example.com",
+    &"-c",
+    &"core.autocrlf=false",
+    &"-c",
+    &"commit.gpgSign=false",
+];
+
+fn run_git_command(
+    command: &dyn AsRef<OsStr>,
+    input: &[&dyn AsRef<OsStr>],
+    cwd: Option<&Path>,
+) -> Result<Output, String> {
+    let git_cmd =
+        &GIT_CMD.into_iter().chain([command]).chain(input.iter().cloned()).collect::<Vec<_>>()[..];
+    run_command(git_cmd, cwd)
+}
+
+fn run_git_command_with_output(
+    command: &dyn AsRef<OsStr>,
+    input: &[&dyn AsRef<OsStr>],
+    cwd: Option<&Path>,
+) -> Result<(), String> {
+    let git_cmd =
+        &GIT_CMD.into_iter().chain([command]).chain(input.iter().cloned()).collect::<Vec<_>>()[..];
+    run_command_with_output(git_cmd, cwd)
+}
+
 fn prepare_libcore(
     sysroot_path: &Path,
     libgccjit12_patches: bool,
@@ -55,19 +92,12 @@ fn prepare_libcore(
     run_command(&[&"cp", &"-r", &rustlib_dir.join("library"), &sysroot_dir], None)?;
 
     println!("[GIT] init (cwd): `{}`", sysroot_dir.display());
-    run_command(&[&"git", &"init"], Some(&sysroot_dir))?;
+    run_git_command(&"init", &[], Some(&sysroot_dir))?;
     println!("[GIT] add (cwd): `{}`", sysroot_dir.display());
-    run_command(&[&"git", &"add", &"."], Some(&sysroot_dir))?;
+    run_git_command(&"add", &[&"."], Some(&sysroot_dir))?;
     println!("[GIT] commit (cwd): `{}`", sysroot_dir.display());
 
-    // This is needed on systems where nothing is configured.
-    // git really needs something here, or it will fail.
-    // Even using --author is not enough.
-    run_command(&[&"git", &"config", &"user.email", &"none@example.com"], Some(&sysroot_dir))?;
-    run_command(&[&"git", &"config", &"user.name", &"None"], Some(&sysroot_dir))?;
-    run_command(&[&"git", &"config", &"core.autocrlf", &"false"], Some(&sysroot_dir))?;
-    run_command(&[&"git", &"config", &"commit.gpgSign", &"false"], Some(&sysroot_dir))?;
-    run_command(&[&"git", &"commit", &"-m", &"Initial commit", &"-q"], Some(&sysroot_dir))?;
+    run_git_command(&"commit", &[&"-m", &"Initial commit", &"-q"], Some(&sysroot_dir))?;
 
     let mut patches = Vec::new();
     walk_dir(
@@ -105,10 +135,11 @@ fn prepare_libcore(
     for file_path in patches {
         println!("[GIT] apply `{}`", file_path.display());
         let path = Path::new("../../..").join(file_path);
-        run_command_with_output(&[&"git", &"apply", &path], Some(&sysroot_dir))?;
-        run_command_with_output(&[&"git", &"add", &"-A"], Some(&sysroot_dir))?;
-        run_command_with_output(
-            &[&"git", &"commit", &"--no-gpg-sign", &"-m", &format!("Patch {}", path.display())],
+        run_git_command_with_output(&"apply", &[&path], Some(&sysroot_dir))?;
+        run_git_command_with_output(&"add", &[&"-A"], Some(&sysroot_dir))?;
+        run_git_command_with_output(
+            &"commit",
+            &[&"-m", &format!("Patch {}", path.display())],
             Some(&sysroot_dir),
         )?;
     }
@@ -124,10 +155,11 @@ fn prepare_rand() -> Result<(), String> {
     let rand_dir = Path::new("build/rand");
     println!("[GIT] apply `{file_path}`");
     let path = Path::new("../..").join(file_path);
-    run_command_with_output(&[&"git", &"apply", &path], Some(rand_dir))?;
-    run_command_with_output(&[&"git", &"add", &"-A"], Some(rand_dir))?;
-    run_command_with_output(
-        &[&"git", &"commit", &"--no-gpg-sign", &"-m", &format!("Patch {}", path.display())],
+    run_git_command_with_output(&"apply", &[&path], Some(rand_dir))?;
+    run_git_command_with_output(&"add", &[&"-A"], Some(rand_dir))?;
+    run_git_command_with_output(
+        &"commit",
+        &[&"-m", &format!("Patch {}", path.display())],
         Some(rand_dir),
     )?;
 
@@ -154,8 +186,8 @@ where
         println!("`{}` has already been cloned", clone_result.repo_name);
     }
     let repo_path = Path::new(crate::BUILD_DIR).join(&clone_result.repo_name);
-    run_command(&[&"git", &"checkout", &"--", &"."], Some(&repo_path))?;
-    run_command(&[&"git", &"checkout", &checkout_commit], Some(&repo_path))?;
+    run_git_command(&"checkout", &[&"--", &"."], Some(&repo_path))?;
+    run_git_command(&"checkout", &[&checkout_commit], Some(&repo_path))?;
     if let Some(extra) = extra {
         extra(&repo_path)?;
     }