Updating Gnu GCC on Linux

GCC is a major part of any Linux system, it contains a C, C++, Fortran and Java compiler (plus some extras if compiled), it’s also the only compiler recommended to build the GNU C library (glibc) which is required to make a Linux system work, other alternatives are available but not as common.

Most systems use an older compiler for stability reasons since it has been significantly tested, however it’s sometimes desirable to use a cutting edge compiler for maximum performance, generally however you should not replace your system compiler unless you’re happy to deal with any bugs that may appear, this is mainly a concern on a source based system like Arch, Gentoo or BSD.

For this post I’m going to be installing GCC 5.30 on XUbuntu 15.10 x64 with the following libraries:

  • GMP 6.10
  • ISL 0.16
  • MPC 1.03
  • MPFR 3.1.3

You can use your systems version of these or build them with GCC which I chose to do.


The follow tools must be on your system if you intend to follow this post:

  • Gnu Bash (Tested 4.3.42)
  • Gnu Make > 3.80 (Tested 4.0)
  • Gnu GCC > 4.9.x (Tested 5.2.1)
  • Gnu G++ > 4.9.x (Tested 5.2.1)
  • binutils > 2.25 (Tested 2.25.1)
  • awk (Tested mawk 1.3.3)
  • tar, gzip and bzip2 (for unpacking sources)
  • InfoZIP (Tested 3.0)
  • DejaGnu
  • TCL
  • Expect

On XUbuntu 15.10 x64 I only had to do the following:

sudo apt-get install g++ dejagnu

Setting up your build environment

For this I decided to use a separate partition mounted at /media/dev
Make a folder for your sources and build, you need around 15GB of free space, this is what I ended up with:


In the sources folder I downloaded and unpacked GCC 5.30 and the support libraries listed above, these are optional but I recommend you build them instead of using the system ones.

If you decide to build the support libraries you need to move or create a symbolic link to them in the gcc source directory so it ends up like this:


Once that is done go to your build directory /media/dev/build/gcc-buld, unlike many applications you keep the build directory and source completely separate.


There are a lot of configuration options available so I highly recommend you check out the official documentation and other sources (the official documentation is surprisingly sparse), this is what I used to configure:

../../sources/gcc-5.3.0/configure --prefix=/media/dev/tools --disable-nls --disable-multilib

Let’s take a look at each bit:

This is the path to the configure script, you could use a non-relative path here instead.

The prefix is where I want the fully built compiler and related files to be installed when I run make install, other good locations are /usr/local and /usr/opt, do not put it in /usr unless you are completely sure, also do not leave this unset or it will default to /usr.

This disables the native language system which provides errors in your native language, unless you have trouble with English or are building it for distribution you should turn nls off.

Without this gcc will be built for x86 and x64, for my system I have no interest in 32 bit so it’s disabled, keep in mind you will need a 32 bit version of gcc and glibc installed in order to build multilib.

One thing you might want to add is –disable-werror as during the build process it may run into an error, this is nothing to worry about since you will be checking the compiler later.

Once the configuration is complete we can proceed with the build.


The next steps are really simple but rather time consuming, for a complete build of gcc you should allocate at least 4 hours on a fast system (I built on an Intel Core I7 4790 and it took quite a while), for a very slow system you might want to run it overnight.

As for why this takes so long it’s due to two reasons, first Gnu GCC is a complicated bit of software and secondly it has to be built at the bare minimum three times.

The first build known as stage 1 uses your system compiler to build the new version of GCC, this is called bootstrapping, if all is well it goes on to stage 2 where it builds the compiler again with the new version you just built, this ensures the compiler is properly optimized, a final build is done and a comparison is made between stage 2 and 3, this verifies that the compiler is stable.

One important warning should be given though, if you’re going from a rather old compiler straight to the latest there is a very good chance the compile will fail or other strange errors will appear in the compiler, if this occurs you must used a version closer to the system compiler and build your way up to the latest, from a very old compiler this can take several steps so always start with the latest available compiler for your system.

The binutils version isn’t as important, if you want to you can put it in the source tree and it will be built along with gcc.

To compile run the following:

make -j9 bootstrap

The -j9 option tells make to use 9 parallel threads, this speeds up the process many times so make sure you include it, the number should be the total number of logical cores plus 1 (as a general rule), for an I7 with 4 physical cores and hyper threading this comes to 9.

If you don’t have much disk space try bootstrap-lean instead, this will take longer but should use less disk space (I have no idea how much less).

BOOT_CFLAGS can be set to adjust how it’s built, the default is -g -O2, feel free to adjust but be aware if you go too far it may break.

Do not run make without bootstrap, that’s only for when the versions are the same.


Once bootstrapping is complete, hopefully without errors you can move on to the checking process, this take a long time as well but it’s really a bad idea to skip unless you are repeating a build, let me say this again, it’s really a bad idea to skip.

To run the tests:

make -j9 -k check

The -k option ensures it will not stop on any error, at the end you will get a report consisting of:

  • Tests performed
  • Tests that passed
  • Tests that passed unexpectedly
  • Tests that failed
  • Tests that failed unexpectedly

Only the last one you really need to worry about, if the number is low (preferably zero) you should be okay, if it’s more than five you really need to stop and check them, it’s a good idea to report any failures on the gcc-testresults mailing list.


To install simply run:

sudo make install

Assuming you remembered to set your prefix it should all be in the right place, if you really want to install in /usr it’s a good idea to set either –program-prefix= or –program-suffix so it will have a different name to your system compiler.

Go to the bin folder and run ./gcc -v, you should see something similar:

Using built-in specs.
Target: x86_64-unknown-linux-gnu
Configured with: ../../sources/gcc-5.3.0/configure --prefix=/media/dev/tools --disable-nls --disable-multilib : (reconfigured) ../../sources/gcc-5.3.0/configure --prefix=/media/dev/tools --disable-nls --disable-multilib
Thread model: posix
gcc version 5.3.0 (GCC)


It really isn’t that hard to update GCC and well worth it if you’re a programmer or just want to optimize your system as much as possible.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s