Cross build third-party library locations on Linux

Question

Ive been cross compiling my unit-tests to ensure they pass on all the platforms of interest, eg x86-linux, win32, win64, arm-linux

they unit tests require the CUnit library

So I've had to cross compile that also for each platform

That comes with its own autoconf stuff so you can easily cross-build it by specifying --host for configure

The question I have is where is the 'correct' place to have the CUnit libs installed for the various platforms? ie what should I set --prefix to for configure?

My initial guess was:

/usr/local/<platform>/lib/Cunit

ie setting --prefix /usr/local/<platform>

eg --prefix /usr/local/arm-linux-gnueabihf

which on sudo make install gives you:

/usr/local/arm-linux-gnueabihf/doc/CUnit
/usr/local/arm-linux-gnueabihf/include/CUnit
/usr/local/arm-linux-gnueabihf/lib
/usr/local/arm-linux-gnueabihf/share/CUnit

Obviously, if i don't specify a prefix for configure, each platform build overwrites the prev one which is no good

to then successfully link to these platform specific libs i need to specify the relevant lib dir for each target in its own LDFLAGS in the Makefile

Is this the right approach? Have I got the dir structure/location right for this sort of cross-build stuff? I assume there must be a defacto approach but not sure what it is..

possibly configure is supposed to handle all this stuff for me? maybe I just have to set --target correctly and perhaps --enable-multilib ? all with --prefix=/usr/local ?

some of the error msgs i get suggest /usr/lib/gcc-cross might be involve?

From reading more about cross compilation and the Gnu configure and build system it seems that I should just be setting the --target option for the configure step

but how do you know what the target names are? are they some fragment of the cross compiler names?

The 3 cross compilers I am using are:

arm-linux-gnueabihf-gcc-4.8 i686-w64-mingw32-gcc x86_64-w64-mingw32-gcc

allowing me to cross-compile for ARM, win32 and win64

my host is 32 bit ubuntu, which I think might be --host i386-linux, but it seems that configure should get this right as its default

Answer 1

This is the procedure I finally figured out and got to work:

for each of my 3 cross-build tools (arm, win32, win64) my calls to configure looked like:

./configure --host=arm-linux-gnueabihf --build=i686-pc-linux-gnu --prefix=/usr/local/arm-linux-gnueabihf
./configure --host=i686-w64-mingw32 --build=i686-pc-linux-gnu --prefix=/usr/local/i686-w64-mingw32
./configure --host=x86_64-w64-mingw32 --build=i686-pc-linux-gnu --prefix=/usr/local/x86_64-w64-mingw32

each of these was followed by make , sudo make install

prior to calling configure for the arm cross build i had to do:

ln -s /usr/bin/arm-linux-gnueabihf-gcc-4.8 /usr/bin/arm-linux-gnueabihf-gcc

this was because the compiler had -4.8 tagged on the end so configure could not correctly 'guess' the name of the compiler

this issue did not apply to either the win32 or win64 mingw compilers

Note an additional gotcha was that when subsequently trying to link to these cross compiled CUnit libs, none of the cross compilers seemed to look in /usr/local/include by default so I had to manually add:

-I/usr/local/include 

for each object file build

eg i added /usr/local/include to INCLUDE_DIRS in my Makefile

all this finally seems to have given me correctly cross built CUnit libs and I have successfully linked to them to produce cross built unit test binaries for each of the target platforms.

not at all easy and I would venture to call the configure option settings 'counter-intuitive' - as ever it is worth taking the time to read the relevant docs - this snippet was pertinent:

There are three system names that the build knows about: the machine you are building on (build), the machine that you are building for (host), and the machine that GCC will produce code for (target). When you configure GCC, you specify these with --build=, --host=, and --target=.

Specifying the host without specifying the build should be avoided, as configure may (and once did) assume that the host you specify is also the build, which may not be true.

If build, host, and target are all the same, this is called a native. If build and host are the same but target is different, this is called a cross. If build, host, and target are all different this is called a canadian (for obscure reasons dealing with Canada's political party and the background of the person working on the build at that time). If host and target are the same, but build is different, you are using a cross-compiler to build a native for a different system. Some people call this a host-x-host, crossed native, or cross-built native.

and also:

When people configure a project like './configure', man often meets these three confusing options, which are more related with cross-compilation

 --host: In which system the generated program will run. --build: In which system the program will be built. --target: this option is only used to build a cross-compiling toolchain. When the tool chain generates executable program, in which target system the program will run. 

An example of tslib (a mouse driver library)

'./configure --host=arm-linux --build=i686-pc-linux-gnu': the dynamically library is built on a x86 linux computer but will be used for a embedded arm linux system.