26. Cross Compilation with GNU Autotools
Normally, when you build a program, it runs on the system on which you
built it. For example, if you compile a simple program, you can
immediately run it on the same machine.
This is normally how GNU Autotools is used as well. You run the
`configure' script on a particular machine, you run
the same machine, and the resulting program also runs on the same
machine. However, there are cases where it is useful to build a program
on one machine and run it on another.
One common example is a program which runs on an embedded system.
An embedded system is a special purpose computer, often part of a larger
system, such as the computers found within modern automobiles. An
embedded system often does not support a general programming
environment, so there is no way to run a shell or a compiler on the
embedded system. However, it is still necessary to write programs to
run on the embedded system. These programs are built on a different
machine, normally a general purpose computer. The resulting programs
can not be run directly on the general purpose computer. Instead, they
are copied onto the embedded system and run there. (We are omitting
many details and possibilities of programming embedded systems here, but
this should be enough to understand the the points relevant to
GNU Autotools. For more information, see a book such as Programming
Embedded Systems by Michael Barr.)
Another example where it is useful to build a program on one machine and
run it on another is the case when one machine is much faster. It can
sometimes be useful to use the faster machine as a compilation server,
to build programs which are then copied to the slower machine and run
Building a program on one type of system which runs on a different type
of system is called cross compiling. Doing this requires a
specially configured compiler, known as a cross compiler.
Similarly, we speak of cross assemblers, cross linkers, etc. When it is
necessary to explicitly distinguish the ordinary sort of compiler, whose
output runs on the same type of system, from a cross compiler, we call
the ordinary compiler a native compiler. Although the debugger is
not strictly speaking a compilation tool, it is meaningful to speak of a
cross debugger: a debugger which is used to debug code which runs on
GNU Autotools supports cross compilation in two distinct though related
ways. Firstly, GNU Autotools supports configuring and building a cross
compiler or other cross compilation tools. Secondly, GNU Autotools
supports building tools using a cross compiler (this is sometimes called
a Canadian Cross). In the rest of this chapter we will explain
how to use GNU Autotools to do these tasks.
If you are not interested in doing cross compilation, you may skip this
chapter. However, if you are developing `configure' scripts, we
recommend that you at least skim this chapter to get some hints as to
how to write them so that it is possible to build your package using a
cross compiler; in particular, see 26.4.6 Supporting Building with a Cross Compiler.
Even if your package is useless for an embedded system, it is possible
that somebody with a very fast compilation server will want to use it to
cross compile your package.