Repository files navigation

This is a GCC codegen for rustc, which means it can be loaded by the existing rustc frontend, but benefits from GCC: more architectures are supported and GCC's optimizations are used.

Despite its name, libgccjit can be used for ahead-of-time compilation, as is used here.

The primary goal of this project is to be able to compile Rust code on platforms unsupported by LLVM.A secondary goal is to check if using the gcc backend will provide any run-time speed improvement for the programs compiled using rustc.

This requires a patched libgccjit in order to work.You need to use myfork of gcc which already includes these patches.

To build it (most of these instructions come fromhere, so don't hesitate to take a look there if you encounter an issue):

$ git clone https://github.com/antoyo/gcc$ sudo apt install flex libmpfr-dev libgmp-dev libmpc3 libmpc-dev$ mkdir gcc-build gcc-install$cd gcc-build$ ../gcc/configure \    --enable-host-shared \    --enable-languages=jit \    --enable-checking=release\# it enables extra checks which allow to find bugs    --disable-bootstrap \    --disable-multilib \    --prefix=$(pwd)/../gcc-install$ 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 theconfigure:

--enable-languages=jit,c++

Then to run libgccjit tests:

$cd gcc# from the `gcc-build` folder$ make check-jit# To run one specific test:$ make check-jit RUNTESTFLAGS="-v -v -v jit.exp=jit.dg/test-asm.cc"

Put the path to your custom build of libgccjit in the filegcc_path.

$ dirname$(readlink -f`find. -name libgccjit.so`)> gcc_path

Then you can run commands like this:

$ ./y.sh prepare# download and patch sysroot src and install hyperfine for benchmarking$ LIBRARY_PATH=$(cat gcc_path) LD_LIBRARY_PATH=$(cat gcc_path) ./y.sh build --release --features master

To run the tests:

$ ./y.shtest --release --features master

$CG_GCCJIT_DIR is the directory you cloned this repo into in the following instructions:

export CG_GCCJIT_DIR=[the full path to rustc_codegen_gcc]

$ 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 useCHANNEL="debug" instead or omitCHANNEL="release" completely.

To use LTO, you need to set the variableFAT_LTO=1 andEMBED_LTO_BITCODE=1 in addition to settinglto = "fat" in theCargo.toml.Don't setFAT_LTO when compiling the sysroot, though: only setEMBED_LTO_BITCODE=1.

Failing to setEMBED_LTO_BITCODE will give you the following error:

error: failed to copy bitcode to object file: No such file or directory (os error 2)

You should prefer using the Cargo method.

$ LIBRARY_PATH=$(cat gcc_path) LD_LIBRARY_PATH=$(cat gcc_path) rustc +$(cat$CG_GCCJIT_DIR/rust-toolchain| grep'channel'| cut -d'=' -f 2| sed's/"//g'| sed's/ //g') -Cpanic=abort -Zcodegen-backend=$CG_GCCJIT_DIR/target/release/librustc_codegen_gcc.so --sysroot$CG_GCCJIT_DIR/build_sysroot/sysroot my_crate.rs

CG_GCCJIT_INCR_CACHE_DISABLED

Don't cache object files in the incremental cache. Useful during development of cg_gccjit to make it possible to use incremental mode for all analyses performed by rustc without caching object files when their content should have been changed by a change to cg_gccjit.

CG_GCCJIT_DISPLAY_CG_TIME

Display the time it took to perform codegen for a crate

CG_RUSTFLAGS

Send additional flags to rustc. Can be used to build the sysroot without unwinding by setting `CG_RUSTFLAGS=-Cpanic=abort`.

CG_GCCJIT_DUMP_TO_FILE

Dump a C-like representation to /tmp/gccjit_dumps and enable debug info in order to debug this C-like representation.

While this crate is licensed under a dual Apache/MIT license, it links tolibgccjit which is under the GPLv3+ and thus, the resulting toolchain (rustc + GCC codegen) will need to be released under the GPL license.

However, programs compiled withrustc_codegen_gcc do not need to be released under a GPL license.

Sometimes, libgccjit will crash and output an error like this:

during RTL pass: expandlibgccjit.so: error: in expmed_mode_index, at expmed.h:2490x7f0da2e61a35 expmed_mode_index../../../gcc/gcc/expmed.h:2490x7f0da2e61aa4 expmed_op_cost_ptr../../../gcc/gcc/expmed.h:2710x7f0da2e620dc sdiv_cost_ptr../../../gcc/gcc/expmed.h:5400x7f0da2e62129 sdiv_cost../../../gcc/gcc/expmed.h:5580x7f0da2e73c12 expand_divmod(int, tree_code, machine_mode, rtx_def*, rtx_def*, rtx_def*, int)../../../gcc/gcc/expmed.c:43350x7f0da2ea1423 expand_expr_real_2(separate_ops*, rtx_def*, machine_mode, expand_modifier)../../../gcc/gcc/expr.c:92400x7f0da2cd1a1e expand_gimple_stmt_1../../../gcc/gcc/cfgexpand.c:37960x7f0da2cd1c30 expand_gimple_stmt../../../gcc/gcc/cfgexpand.c:38570x7f0da2cd90a9 expand_gimple_basic_block../../../gcc/gcc/cfgexpand.c:58980x7f0da2cdade8 execute../../../gcc/gcc/cfgexpand.c:6582

To see the code which causes this error, call the following function:

gcc_jit_context_dump_to_file(ctxt,"/tmp/output.c",1/* update_locations */)

This will create a C-like file and add the locations into the IR pointing to this C file.Then, rerun the program and it will output the location in the second line:

libgccjit.so: /tmp/something.c:61322:0: error: in expmed_mode_index, at expmed.h:249

Or add a breakpoint toadd_error in gdb and print the line number using:

p loc->m_linep loc->m_filename->m_buffer

To print a debug representation of a tree:

debug_tree(expr);

(defined in print-tree.h)

To print a debug representation of a gimple struct:

debug_gimple_stmt(gimple_struct)

To get therustc command to run ingdb, add the--verbose flag tocargo build.

To have the correct file paths ingdb instead of/usr/src/debug/gcc/libstdc++-v3/libsupc++/eh_personality.cc:

Maybe by calling the following at the beginning of gdb:

set substitute-path /usr/src/debug/gcc /path/to/gcc-repo/gcc

TODO(antoyo): but that's not what I remember I was doing.

When you get this error:

error: failed to build archive: failed to open object file: No such file or directory (os error 2)

That can be caused by the fact that you try to compile withlto = "fat", but you didn't compile the sysroot with LTO.(Not sure if that's the reason since I cannot reproduce anymore. Maybe it happened when forgetting settingFAT_LTO.)

When compiling an executable with libgccijt, if setting the*LIBRARY_PATH variables to the install directory, you will get the following errors:

ld: cannot find crtbegin.o: No such file or directoryld: cannot find -lgcc: No such file or directoryld: cannot find -lgcc: No such file or directorylibgccjit.so: error: error invoking gcc driver

To fix this, set the variables togcc-build/build/gcc.

Run do the command with-v -save-temps and then extract thelto1 line from the output and run that under the debugger.

CG_RUSTFLAGS="-Clink-args=-save-temps -v" ../y.sh cargo build

CG_RUSTFLAGS="-Clink-arg=-save-temps -v -Clink-arg=-dA" ../y.sh cargo build

cargo build -v --target x86_64-unknown-linux-gnu -Zbuild-std# Take the command from the output and add --emit=llvm-ir

Run with:

COLLECT_NO_DEMANGLE=1

• Build the stage2 compiler (rustup toolchain link debug-current build/x86_64-unknown-linux-gnu/stage2).
• Clean and rebuild the codegen withdebug-current in the filerust-toolchain.

Using git-subtree withrustc requires a patched git to make it work.The PR that is needed ishere.Use the following instructions to install it:

git clone git@github.com:tqc/git.gitcd gitgit checkout tqc/subtreemakemake installcd contrib/subtreemakecp git-subtree~/bin

Then, do a sync with this command:

PATH="$HOME/bin:$PATH"~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_namecd ../rustc_codegen_gccgit checkout mastergit pullgit checkout sync_branch_namegit merge master

To send the changes to the rust repo:

cd ../rustgit pull origin mastergit checkout -b subtree-update_cg_gcc_YYYY-MM-DDPATH="$HOME/bin:$PATH"~/bin/git-subtree pull --prefix=compiler/rustc_codegen_gcc/ https://github.com/rust-lang/rustc_codegen_gcc.git mastergit push# Immediately merge the merge commit into cg_gcc to prevent merge conflicts when syncing from rust-lang/rust later.PATH="$HOME/bin:$PATH"~/bin/git-subtree push -P compiler/rustc_codegen_gcc/ ../rustc_codegen_gcc/ sync_branch_name

TODO: write a script that does the above.

https://rust-lang.zulipchat.com/#narrow/stream/301329-t-devtools/topic/subtree.20madness/near/258877725

rustc needs to be built withoutjemalloc so thatmem-trace can overloadmalloc sincejemalloc is linked statically, so aLD_PRELOAD-ed library won't a chance to intercept the calls tomalloc.

If you need to check what gccjit is generating (GIMPLE), then take a look at how togenerate it ingimple.md.

• Follow the instructions onthis repo.

• Run./y.sh prepare --cross so that the sysroot is patched for the cross-compiling case.
• Set the path to the cross-compiling libgccjit ingcc_path.
• Make sure you have the linker for your target (for instancem68k-unknown-linux-gnu-gcc) in your$PATH. Currently, the linker name is hardcoded as being$TARGET-gcc. Specify the target when building the sysroot:./y.sh build --target-triple m68k-unknown-linux-gnu.
• Build your project by specifying the target:OVERWRITE_TARGET_TRIPLE=m68k-unknown-linux-gnu ../y.sh cargo build --target m68k-unknown-linux-gnu.

If the target is not yet supported by the Rust compiler, create atarget specification file (note that thearch specified in this file must be supported by the rust compiler).Then, you can use it the following way:

• Add the target specification file using--target as anabsolute path to build the sysroot:./y.sh build --target-triple m68k-unknown-linux-gnu --target $(pwd)/m68k-unknown-linux-gnu.json
• Build your project by specifying the target specification file:OVERWRITE_TARGET_TRIPLE=m68k-unknown-linux-gnu ../y.sh cargo build --target path/to/m68k-unknown-linux-gnu.json.

If you get the following error:

/usr/bin/ld: unrecognised emulation mode: m68kelf

Make sure you setgcc_path to the install directory.