Cross
As simple as
cross make arm-none-eabi
Cross-compiler environment management
Dependencies
cross
itself depends on lua
and a shell environment. It also makes use of git
, svn
, and potentially hg
for version control.
GCC depends on a large number of things, including autoconf
, automake
, autopoint
, gettext
, and texinfo
to build, and possibly more. You can find out either by interpreting GCC's errors when you attempt to compile, or by looking them up at http://gcc.gnu.org/install/prerequisites.html.
cross
subcommands
cross
comes bundled with a few useful commands.
make
cross make TARGET [BUILD_PARAMS ...]
'TARGET' is your standard target triple, such as 'x86_64-pc-mingw32'.
'BUILD_PARAMS' are parameters in the form KEY=VALUE which override any other configuration options. More on those later.
version
cross version
Outputs the cross
version number.
help
cross help [subcommand]
Outputs either the list of subcommands or the help text for a specific subcommand.
Target Configurations
Cross comes bundled with what could be considered 'sane defaults' for embedded systems-type target architectures. The head version of GCC is built first without headers, then newlib is built with that GCC, then GCC is rebuilt again with newlib as the included C library.
For quite a few targets these defaults work pretty okay, but if they don't, cross
is highly configurable.
cross
looks in its cmd/targets directory for files named after the target given. If it exists, the file is loaded
as a lua table and searched for override parameters. Parameters it looks for include:
SKIP_BISON
or SKIP_FLEX
These, if present, make the build system skip building both flex and bison (prerequisites for building GCC)
t_VERSION
Where 't' is any of FLEX, BISON, BINUTILS, GCC, GCC_2, or LIBC
This, by default, indicates a specific version of that dependency is necessary. cross
will try to checkout the given version from the repo (with hg/git/svn tags).
Build Stage Overrides
t_OVERRIDE
Where 't' is any of FLEX, BISON, BINUTILS, GCC, GCC_2, or LIBC
This lets you specify a table to completely override that stage of the build.
The table has the fields 'target' and 'output' set to its output dir and target-triple,
Then, if the table specifies a 'method' (and, implicitly, a 'url') field, then
the cross
internal source control function is used to download that version.
If method
is not specified, cross
expects the table to be callable, and return the directory that dependency's source is in when called.
cross
also expects the override table to have a 'builder' string. This string has the override table applied to it as a handlebars-esque context
and then is run from the shell from within the directory the source is in. This is usually something as simple as
./configure; make; make install;
Any combination of these can be present in the table, and they can be overridden again with parameters to the make
subcommand.
As an example, you can force cross
to build GCC 4.8.0 on arm-none-eabi
by making the file ~/.cross/cmd/targets/arm-none-eabi
:
GCC_2_VERSION = "gcc-4_8_0-release", --for the final compilation
GCC_VERSION = "gcc-4_8_0-release", --since it's probably a good idea to build the same version when we bootstrap
How cross works
cross is based off of rbenv
. As such, there are a number of similarities. Namely, shims. Unlike rbenv, you should never need
to rehash
yourself, just leave it to cross.
Why does cross
have shims? To enable a feature called a 'target override'.
If you want to make
something for a new target, usually you'd need to make a new makefile referencing the new target's build executables.
cross alleviates this need. Instead, place a .cross_target file in the same directory as the makefile and make its contents your desired target.
i.e.:
echo "arm-none-eabi" >> .cross_target
cross's shims will look for this file when you run gcc, g++, or any executable compiled by cross and override it with the target-specific version when this file is present.