Toolchains

A toolchain is a complete collection of compiler and binutils programs and can be run either as a cross-compiler, or native on the target (if performance allows).

Pre-built/Build Kits

MIPS SDE

MIPS Technologies UK maintains their own source tree for the toolchain components. SDE combines all necessary GNU tools, is infrequently resynchronized with mainstream GNU releases (which inevitably have bugs for less widely used architectures such as MIPS) and focuses on supporting the full range of ISAs, ASEs and cores, as well as providing the most reliable, best-performing compiler for the largest range of MIPS CPUs. See MIPS SDE Installation. Note that the pre-built cross-compiler is only suitable for building a Linux kernel, and cannot be used to create Linux applications or shared objects. Note: We have been using the sde toolkit for both shared objects and applications. Maybe the issue was fixed?

Maciej W. Rozycki

A stable set of toolchain components provided by Maciej can be downloaded from ftp://ftp.linux-mips.org/pub/linux/mips/people/macro/. This is based on GCC 2.95.3 (patched) and up-to-date binutils. Versions 4.0.1 and 4.1.2 of GCC are available too.

The former mirror at ftp.rfc822.org is now gone. Thanks, Florian, for providing this service over the years.

Dan Kegel

Dan Kegel has a page at http://kegel.com/crosstool/ with a nice script to automatize the build procedure. Crosstool can only generate toolchains that use the GNU C Library, support for the smaller C Library http://www.uclibc.org uClibc might be added in the future.

H.J.Lu

H.J.Lu distributes a toolchain as part of his Red Hat 7.1 port. It can be found at ftp://ftp.linux-mips.org/pub/linux/mips/redhat/7.1/ . This toolchain-20020423-1.rpm is based on the RedHat's GCC 2.96, binutils 2.13 and glibc 2.2.5 .

uClibc Toolchain and Buildroot

uClibc developers provide tools to generate toolchains and root filesystems with the uClibc standard C library.

The Toolchain tool allows to generate a toolchain for a variety of architectures, including MIPS and MIPSel.

The Buildroot tool allows to generate both a toolchain and a root filesystem for a variety of architectures, including MIPS and MIPSel. Using a configuration tool (similar to the one used for the Linux Kernel), you can select compiler version, binutils version, and all softwares that should be included in the root filesystem. Then the Makefiles will automatically download, configure, compile, install and generate the toolchain and the root filesystem image.

OpenEmbedded

The OpenEmbedded meta distribution also includes an automatic build of a full cross-toolchain for it's target architecture. http://www.openembedded.org

DENX ELDK

DENX Software Engineering provides the ELDK (Embedded Linux Development Kit), which includes both cross development and native tools for big and little endian MIPS processors (also for ARM and PowerPC). As it is Free Software it can be downloaded for FREE. See http://www.denx.de/wiki/DULG/ELDK

Gentoo crossdev

Gentoo provides a tool for creating full cross-compiling toolchains for a number of targets. On any Gentoo system, set up PORTAGE_OVERLAY in make.conf, then emerge crossdev to install it. Using a small startup shell script, these toolchains can be used with distcc as well, to allow distribution of a compile job over a cluster.

Debian

Embedded Debian project provides cross toolchains for various platforms, including mips and mipsel.

An alternative repository with newer toolchains built from Debian sources is available from [1].

Sourcery CodeBench Lite Edition

Mentor Graphics provides pre-built MIPS toolchains for x86 and x86_64 hosts. Apart from the core toolchain components (binutils, gcc), the package also includes gdb, gdbserver and qemu. As of the time of writing, the N32 ABI is not supported by this toolchain.

Commercial Toolchains

All commercial Linux/MIPS distributions come with appropriate toolchain deliverables.

Cygwin

Here is a first attempt at GCC 4.9.2 and Binutils 2.25 compiled on/for 32-bit Cygwin and targeting mips-unknown-linux-gnu. Untested for Linux kernel builds.

Roll-your-own

You're adverse to using someone else's toolchains, and cannot remember how to build one yourself, no matter how hard you try. Fear not. Outlined here is the proceedure to build a bootstrap toolchain; one which is minus the C library and is just enough to build the kernel.

Prologue

What you'll need:

binutils-2.24 (latest as of 2013-12-02)
gcc-4.8.2 (latest as of 2013-10-16)
gdb-7.7 (latest as of 2014-02-05)

Note that in general you want to use the latest versions released by the time a kernel was released. The versions listed here are known to be working well for recent kernels as of the time of writing. Using tools more recent than the kernel means that combination will not have been tested exhaustively so the likelihood of encountering incompatibilities increases. Sometimes tool compatibility versions are fixed in -stable but there is no guarantee that this also covers your favorite esoteric configuration.

Now, export a few environment variables for your convenience. If you're building for big-endian MIPS, your TARGET should be mips-unknown-linux-gnu instead. If you wish to install to a different location other than /opt/cross/, substitute in your PREFIX accordingly. A common alternative is /usr/local/.

% export WDIR=/tmp
% export TARGET=mipsel-unknown-linux-gnu
% export PREFIX=/opt/cross

You'll need to re-export your PATH with the new install location so when building a bootstrap gcc, it may locate the shiny new cross-binutils:

% export PATH="${PATH}":${PREFIX}/bin

Now change to the staging directory:

% cd $WDIR
% mkdir ${TARGET}-toolchain  && cd ${TARGET}-toolchain

Binutils

Extract, configure, build and install:

% tar xjf binutils-2.24.tar.bz2
% mkdir build-binutils && cd build-binutils
% ../binutils-2.24/configure --target=$TARGET --prefix=$PREFIX
% make
% make install
% cd ..

You should now have the cross-binutils installed under ${PREFIX}/bin/ with names prefixed by mipsel-unknown-linux-gnu-* (or mips-unknown-linux-gnu-* if you're building for big-endian MIPS).

GCC

Extract, configure, build and install a bootstrap GCC.

Enable any other language front-ends as you see fit. For building the kernel however, you can get away with just the C language front-end. Also, tell the configure script not to look for target libc headers -- we don't have them, and don't need them at this point.

% tar xjf gcc-4.8.2.tar.bz2
% mkdir build-gcc-bootstrap && cd build-gcc-bootstrap
% ../gcc-4.8.2/configure --target=$TARGET --prefix=$PREFIX \
  --enable-languages=c --without-headers \
  --with-gnu-ld --with-gnu-as \
  --disable-shared --disable-threads \
  --disable-libmudflap --disable-libgomp \
  --disable-libssp --disable-libquadmath \
  --disable-libatomic
% make -j2
% make install
% cd ..

GDB

You'll need this for debugging either the kernel (with KGDB) or userspace (natively or with gdbserver). If this doesn't apply in your case, you may safely skip this section.

Extract, configure, build and install:

% tar xjf gdb-6.3.tar.bz2
% mkdir build-gdb && cd build-gdb
% ../gdb-6.3/configure --target=$TARGET --prefix=$PREFIX
% make
% make install
% cd ..

Summary

Your shiny new toolchain should be in your PATH, given you re-exported it earlier. Otherwise, you'll need to prefix your PATH with:

% ${PREFIX}/bin/mipsel-unknown-linux-gnu-

or for a big-endian target:

% ${PREFIX}/bin/mips-unknown-linux-gnu-

Enjoy.