As of writing, the latest Native-code Development Kit for Android (r6) comes with gcc 4.4.3 and binutils 2.19 for ARM. The combination is a quite old toolchain, that lacks various novelties, such as properly working Profile Directed Optimization (a.k.a. Profile Guided Optimization), or Identical Code Folding.
The first thing that is needed to rebuild a custom NDK, is the NDK itself.
$ wget http://dl.google.com/android/ndk/android-ndk-r6-linux-x86.tar.bz2 $ tar -xjf android-ndk-r6-linux-x86.tar.bz2 $ cd android-ndk-r6
Next, you need to get the NDK source (this can take a little while and requires git, but see further below if you want to skip this part):
$ ./build/tools/download-toolchain-sources.sh src
Rebuilding the NDK toolchain binaries is quite simple:
$ ./build/tools/build-gcc.sh $(pwd)/src $(pwd) arm-linux-androideabi-4.4.3
But this doesn’t get you anything modern. It only rebuilds what you already have.
The GCC 4.4.3 that comes with the NDK is actually quite heavily patched. Fortunately, only a few patches are required for gcc 4.6.1 to work with the NDK (corresponding upstream bug).
In order to build a newer GCC and binutils, you first need to download the source for GCC (I took 4.6.1) and binutils (I took the 2.21.53 snapshot, see further below), as well as GMP, MPFR and MPC. The latter was not a requirement to build GCC 4.4. GMP and MPFR are with the NDK toolchain sources, but the versions available there are too old for GCC 4.6.
All the sources must be placed under src/name, where name is gcc, binutils, mpc, mpfr, or gmp. The sources for MPC, MPFR and GMP need to remain as tarballs, but the sources for GCC and binutils need to be extracted (don’t forget to apply the patch linked above to GCC). In the end you should have the following files/directories:
src/gcc/gcc-4.6.1/src/binutils/binutils-2.21.53/src/gmp/gmp-5.0.2.tar.bz2src/mpc/mpc-0.9.tar.gzsrc/mpfr/mpfr-3.0.1.tar.bz2
If you skipped the NDK toolchain source download above, you will also need the gdb sources. NDK comes with gdb 6.6, so you should probably stay with that one. The source needs to be extracted like GCC and binutils, so you’ll have a src/gdb/gdb-6.6/ directory. Another part you will need is the NDK build scripts, available on git://android.git.kernel.org/toolchain/build.git. They should be put in a src/build/ directory. For convenience, you may directly download a tarball.
You then need to edit the build/tools/build-gcc.sh script to add support for MPC:
Add the following lines somewhere around similar lines in the script:
MPC_VERSION=0.8.1 register_var_option "--mpc-version=<version>" MPC_VERSION "Specify mpc version"
And add the following to the configure command in the script:
--with-mpc-version=$MPC_VERSION
If you want to use gold by default instead of GNU ld, you can also add, at the same place:
--enable-gold=default
If you want a GNU libstdc++ compiled as Position Independent Code (note that by default, the NDK won’t use GNU libstdc++, but its own), you can add, at the same place:
--with-pic
Once all this preparation is done, you can build your new NDK toolchain with the following command:
$ ./build/tools/build-gcc.sh --gmp-version=5.0.2 --mpfr-version=3.0.1 --mpc-version=0.9 --binutils-version=2.21.53 $(pwd)/src $(pwd) arm-linux-androideabi-4.6.1
If you’re running a 64-bits system on x86-64, you can also add the --try-64 option to the above command, which will give you a 64-bits toolchain to cross-build ARM binaries, instead of the 32-bits toolchain you get by default.
When building Firefox with this new toolchain, you need to use the following in your .mozconfig:
ac_add_options --with-android-toolchain=/path/to/android-ndk-r6/toolchains/arm-linux-androideabi-4.6.1/prebuilt/linux-x86
Or the following for the 64-bits toolchain:
ac_add_options --with-android-toolchain=/path/to/android-ndk-r6/toolchains/arm-linux-androideabi-4.6.1/prebuilt/linux-x86_64
Note that currently, elfhack doesn’t support the resulting binaries very well, so you will need to also add the following to your .mozconfig:
ac_add_options --disable-elf-hack
Or, if you don’t want to build it yourself, you can get the corresponding pre-built NDK (32-bits) (thanks to Brad Lassey for the temporary hosting). Please note it requires libstdc++ from gcc 4.5 or higher.
Here is a list of things you may need to know if you want to try various combinations of versions, and that I had to learn the hard way:
- GCC 4.6.1 doesn’t build with binutils 2.19 (GNU assembler lacks support for a few opcodes it uses)
- GNU ld >= 2.21.1 has a crazy bug that leads to a crash of Firefox during startup. There is also a workaround.
- Gold fails to build with gcc 4.1.1 (I was trying to build in the environment we use on the buildbots) because of warnings (it uses -Werror) in some versions, and because of an Internal Compiler Error with other versions.
- When building with a toolchain that is not in the standard directory and that is newer than the system toolchain (like, in my case, using gcc 4.5 in /tools/gcc-4.5 instead of the system gcc 4.1.1), gold may end up with a libstdc++ dependency that is not satisfied with the system libstdc++. In that case, the NDK toolchain build will fail with the error message “Link tests are not allowed after GCC_NO_EXECUTABLES.”, which isn’t exactly helpful to understand what is wrong.
- At some point, I was getting the same error as above when the build was occurring in parallel, and adding
-j1to thebuild-gcc.shcommand line solved it. It hasn’t happened to me in my recent attempts, though.
- Gold 2.21.1 crashes when using Identical Code Folding. This is fixed on current binutils HEAD (which is why I took 2.21.53).