Note this currently contains various recipes:

• Recipe1: Building for an ARM CrOS device
• Recipe2: Explicit Cross compiling
• Recipe3: Packaged/Automated Cross compiling

Recipe1: Building for an ARM CrOS device

Because this recipe uses NinjaBuild it's can be faster than the make-based builds in the other recipes. It also replaces the need to install a cross-compiler with the need for a CrOS chroot, which any CrOS ARM developer will already have set up.

Baseline: ebuild

The most commonly-used way ARM binaries of chromium get built is using a CrOS chroot and its ebuild system; for details follow the chromium-os developer guide and eventually build binaries from ToT using emerge-<BOARD> chromeos-chrome or build from chromium local-source using CHROME_ORIGIN=LOCAL_SOURCE as described in building-chromium-browser.

Fasterfy: ninja

The ebuild way above has the advantage of being smooth (because of its popularity) but the disadvantage of being very slow (an incremental rebuild of chrome after changing a single file can take minutes). A faster alternative is to build the chrome binary directly in the chroot's view of chromium's src/ tree using the cross-compiler installed in the chroot by the process described above. Example settings to use:

1. Go the ebuild route one time, to make sure everything's set up. In particular a cross-compiler such as /usr/bin/armv7a-cros-linux-gnueabi-gcc is present, and inside the chroot ~/chrome_root/src is a view of the chromium src directory.
2. Set appropriate environment variables; one (working) example set is below; you might want to modify $GYP_DEFINES to suit your needs, and/or make sure any ~/.gyp/include.gypi (in the chroot!) is compatible with these defines:

export BOARD=<BOARD>
export BUILD_OUT=out_${BOARD}
export builddir_name=out_${BOARD}
export CHROME_ORIGIN=LOCAL_SOURCE
export GYP_GENERATOR_FLAGS="output_dir=out_${BOARD} config=Debug"
export GYP_GENERATORS="ninja"
export GYP_DEFINES="$GYP_DEFINES chromeos=1 target_arch=arm armv7=1 arm_neon=0"
export GYP_DEFINES="$GYP_DEFINES disable_nacl=1 enable_svg=0"
export GYP_DEFINES="$GYP_DEFINES proprietary_codecs=1 ffmpeg_branding=Chrome"
export GYP_DEFINES="$GYP_DEFINES linux_use_tcmalloc=0 arm_fpu=vfpv3-d16"
export GYP_DEFINES="$GYP_DEFINES python_ver=2.6 swig_defines=-DOS_CHROMEOS linux_sandbox_path=/opt/google/chrome/chrome-sandbox"
export GYP_DEFINES="$GYP_DEFINES remove_webcore_debug_symbols=1"
export EXTRA_BUILD_ARGS="$GYP_DEFINES"
export SYSROOT=/build/${BOARD}/
export ARMV7BASE="armv7a-cros-linux-gnueabi"
export GOLDIFY="-B/usr/x86_64-pc-linux-gnu/armv7a-cros-linux-gnueabi/binutils-bin/2.21-gold/" #
export SYSROOTFLAG="--sysroot=$SYSROOT"
export ARMIFY="-march=armv7-a -mtune=cortex-a8 -mfpu=vfpv3-d16 -mfloat-abi=softfp"
export BACKTRACE="-funwind-tables -rdynamic"
export GYP_GENERATORS=ninja
export AR_target=$ARMV7BASE-ar
export CC_target="$ARMV7BASE-gcc $SYSROOTFLAG $BACKTRACE $ARMIFY"
export CXX_target="$ARMV7BASE-g++ $SYSROOTFLAG $GOLDIFY $BACKTRACE $ARMIFY"

3. Run ./build/gyp_chromium as usual for non-cross-compile builds
4. Run ninja -C out_<BOARD> -j<CORECOUNT> chrome (googler note: this works great with goma, too)
5. Profit! (but see the Running section below for extra fun!)

Running the new binary

The vanilla way to run a chrome on CrOS is to install it into the system image and re-install the image; this is both extremely slow and extremely frustrating if you introduce a bug that makes the image unusable. A much quicker turn-around way is to run the new binary alongside the system binary. The quickest way to do this is to mount the build output directory from the build host (usually a linux desktop) onto the CrOS device using sshfs, after which the new binary can be run directly. A sample workflow looks like this:

alias crosdevice="ssh -o StrictHostKeyChecking=no -o CheckHostIP=no -i ~/trunk/src/scripts/mod_for_test_scripts/ssh_keys/testing_rsa root@<CROS-IP>"
function initcrosdevice() {
  cd ~/chrome_root/src
  crosdevice 'bash -x -c "echo \"core.%p\" > /proc/sys/kernel/core_pattern && \
    mkdir -p ~chronos/chrome && chown chronos ~chronos/chrome && \
    sudo modprobe fuse && \
    sudo -u chronos /bin/bash -c \"cd ~chronos/chrome && mkdir -p Release Debug\""' && \
  echo "Now log into crosdevice and run:"
  echo "ulimit -c unlimited && cd ~chronos/chrome && sudo -u chronos bash"
  echo "sshfs <BUILDHOSTUSER>@<BUILDHOST>:/home/<BUILDHOSTUSER>/src/chromium/src/out_<BOARD>/Debug Debug && sshfs <BUILDHOSTUSER>@<BUILDHOST>:/home/<BUILDHOSTUSER>/src/chromium/src/out_<BOARD>/Release Release"
  crosdevice
}

Customize to match your CrOS device's IP address, build host name or IP address, and username on the build host (as well as directory paths if your build output directory lives elsewhere). Then run the initcrosdevice function from inside the cros chroot to get an ssh session to the cros device, and follow the instructions printed. Finally, a sample command line to run in that ssh session is:

rm -rf x1 core.[0-9]* && USER=c DISPLAY=:0 XAUTHORITY=/home/chronos/.Xauthority ./Debug/chrome --aura-host-window-use-fullscreen --use-gl=egl --user-data-dir=x1 --no-first-run

(the USER=c part is a workaround for http://crosbug.com/23507 and the rest should be self-explanatory)

Recipe2: Explicit Cross compiling

Due to the lack of ARM hardware with the grunt to build Chromium native, cross compiling is currently the recommended method of building for ARM.

Building a toolchain

Pre-built

CodeSourcery has prebuilt cross-compilers available for download here: http://www.codesourcery.com/sgpp/lite/arm/portal/release1039

Chromium developers have tested using 2009q3. Older versions are known to cause errors when building Chromium.

Build your own

crosstool-ng is a set of scripts capable of building a cross-toolchain from source.

1. Download and install from http://ymorin.is-a-geek.org/projects/crosstool
2. Configure

   $ mkdir toolchain-build
   $ cd toolchain-build
   $ ct-ng arm-none-linux-gnueabi

3. Build. Adjust the number following build to the same number as you would pass to -j when running make.

   $ ct-ng build.6

This will build a toolchain and place it in ~/x-tools/arm-unknown-linux-gnueabi/.

The toolchain-build directory can be safely removed after the build has completed.

Building a rootfs

The easiest way to build a rootfs for linking against is to copy the directories /lib and /usr/lib from the ARM system to a rootfs directory on the build machine. You must take care to ensure any copied symlinks are relative to the copied directory, not to the build machine's root.

If you do not have a pre-existing rootfs, Ubuntu's rootstock tool can be used to create a working ARM system. It is available in Ubuntu 9.10 (Karmic) and newer.

The following example builds an Ubuntu Karmic system. The list of packages to install come from LinuxBuildInstructionsPrerequisites#Ubuntu_Setup, and as such may be out dated. An alternate list may be found in $lib_list from build/install-build-deps.sh.

 $ sudo apt-get install rootstock
 $ sudo rootstock --fqdn beagleboard --login ubuntu --password temppwd \
   --imagesize 2G --seed xfce4,gdm,pkg-config,python,perl,g++,bison,flex,\
   gperf,libnss3-dev,libgtk2.0-dev,libnspr4-0d,libasound2-dev,libnspr4-dev,\
   libgconf2-dev,libcairo2-dev,libdbus-1-dev,libstdc++6-4.4-dev,libexpat1-dev,\
   libxslt1-dev,libxml2-dev,libbz2-dev  --dist karmic

Compiling

1. Set the following gyp variables in ~/.gyp/include.gypi

{
  'variables': {
    'target_arch': 'arm',
    'sysroot': '/path/to/rootfs',
    'disable_nacl': 1,  # NaCL does not build for ARM.
    'linux_use_tcmalloc': 0, # tcmalloc does not build for ARM.
    'armv7': 1, # Optional, for targeting ARMv7.
    'arm_thumb': 1, # Optional, for targetting thumb.  Combine with armv7 to target thumb2.
    'arm_neon': 0, # Optional, to disable NEON. 1 is the default, and most people want to keep it that way.
    'arm_fpu': 'vfpv3-d16', # Optional, to select which version of vfp to use if NEON is off. Default is vfpv3.
  }
}

1. Alternatively you can set your GYP_DEFINES environment variables:

  export GYP_DEFINES="target_arch=arm sysroot=/path/to/rootfs disable_nacl=1 linux_use_tcmalloc=0 armv7=1 arm_thumb=1"

Note: as of 26-aug-2011 you must also set chromeos=1 as well due to problems in libvpx.

1. Set your toolchain environment variables:

  export CROSSTOOL=~/x-tools/arm-unknown-linux-gnueabi/bin/arm-unknown-linux-gnueabi
  export CXX=$CROSSTOOL-g++
  export CC=$CROSSTOOL-gcc
  export AR=$CROSSTOOL-ar
  export AS=$CROSSTOOL-as
  export RANLIB=$CROSSTOOL-ranlib

2. Regenerate your build files by running gclient runhooks
3. Build as normal

  make -r -j6 BUILDTYPE=Release chrome

Using gold

Whether you use the prebuilt toolchain or a custom built one, link times are very high (from 15 minutes in Release to 2+h hours in Debug) Although still experimental, gold on arm got to the point where it can link chrome, and the resulting binary runs fine. gold on arm is only available currently on the top-of-trunk binutils.

  $ mkdir binutils
  $ cd binutils
  $ cvs -z 9 -d :pserver:anoncvs@sourceware.org:/cvs/src login
  (only needed the first time; enter "anoncvs" as the password)
  $ cvs -z 9 -d :pserver:anoncvs@sourceware.org:/cvs/src co binutils
  $ cd src
  $ ./configure  --enable-gold  --target=arm-none-linux-gnueabi
  $ make -i
  $ cd ..
  $ ln -s src/gold/ld-new ld

Then modify the CC and CXX lines above adding -B /path/to/binutils to indicate the path to the ld symlink that was created above (that is, /path/to/binutils/ld should be the gold binary), e.g.

  $ export CC="$CROSSTOOL-gcc -B /path/to/binutils"
  $ export CXX="$CROSSTOOL-g++ -B /path/to/binutils"

Then, rebuild chrome as usual.

For the arm buildbot, run configure with --prefix=/usr/local/tot-binutils. This will install gold into /usr/local/tot-binutils/arm-none-linux-gnueabi/bin/ld. Then to make the bot find the correct binutils, edit /b/scripts/slave/compile.py, and look for the stanza that sets 'CC' and 'CC'. It should look like:

os.environ['CC'] = crosstool + '-gcc'.
os.environ['CXX'] = crosstool + '-g++'.

Change it so that it says:

os.environ['CC'] = crosstool + '-gcc -B/usr/local/tot-binutils/arm-none-linux-gnueabi/bin'.
os.environ['CXX'] = crosstool + '-g++ -B/usr/local/tot-binutils/arm-none-linux-gnueabi/bin'.

Testing

If you don't have a real ARM machine, you can test with QEMU. For instance, there are some prebuilt QEMU Debian images here: http://people.debian.org/~aurel32/qemu/. Another option is to use the rootfs generated by rootstock, as mentioned above.

Here's a minimal xorg.conf if needed:

Section "InputDevice"
        Identifier      "Generic Keyboard"
        Driver          "kbd"
        Option          "XkbRules"      "xorg"
        Option          "XkbModel"      "pc105"
        Option          "XkbLayout"     "us"
EndSection

Section "InputDevice"
        Identifier      "Configured Mouse"
        Driver          "mouse"
EndSection

Section "Device"
        Identifier      "Configured Video Device"
        Driver  "fbdev"
        Option          "UseFBDev"              "true"
EndSection

Section "Monitor"
        Identifier      "Configured Monitor"
EndSection

Section "Screen"
        Identifier      "Default Screen"
        Monitor         "Configured Monitor"
        Device          "Configured Video Device"
        DefaultDepth 8
        SubSection "Display"
            Depth 8
            Modes "1024x768" "800x600" "640x480"
        EndSubSection
EndSection

Notes

• To building for thumb reduces the stripped release binary by around 9MB, equating to ~33% of the binary size. To enable thumb, set 'arm_thumb': 1
• Native client is currently disabled.
• TCmalloc does not have an ARM port, so it is disabled.

Recipe3: Packaged/Automated Cross compiling

This recipe describes how to cross compile chrome on an x86 ubuntu system to an arm ubuntu system (natty, and up).

This worked as of version 114696

Note: for simplicity the recipe steps have been move into a script, chrome-setup.sh , which can be found here:

http://codereview.chromium.org/8967004/

The script should be run from inside the src/ directory in a chrome client

Step 1: Install basic cross tool components

This needs to be run only once per machine.

chrome-setup.sh install-cross-toolchain-base

Step 2: Install additional cross tool jail

This jail is pre-built and can be installed like so:

chrome-setup.sh install-cross-toolchain-jail

This step needs to be run only once per client and could be modified to be necessary only once per machine.

Step 3: Configure Chrome Build

chrome-setup.sh  configure-chrome

Step 4: Build Chrome

chrome-setup.sh make-chrome

You maybe want to change the parallelism (currently: -j 16)

Step 5: Package Chrome

chrome-setup.sh package-chrome

This creates a tarball for shipping to/testing on the target system.