File.........: 5 - Using the toolchain.txt

Copyright....: (C) 2010 Yann E. MORIN <yann.morin.1998@anciens.enib.fr>

License......: Creative Commons Attribution Share Alike (CC-by-sa), v2.5

Using the toolchain  /

____________________/

Using the toolchain is as simple as adding the toolchain's bin directory in

your PATH, such as:

  export PATH="${PATH}:/your/toolchain/path/bin"

and then using the '--host' tuple to tell the build systems to use your

toolchain (if the software package uses the autotools system you should

also pass --build, for completeness):

  ./configure --host=your-host-tuple --build=your-build-tuple

or

  make CC=your-host-tuple-gcc

or

  make CROSS_COMPILE=your-host-tuple-

and so on...

(Note: in the above example, 'host' refers to the host of your program,

not the host of the toolchain; and 'build' refers to the machine where

you build your program, that is the host of the toolchain.)

It is strongly advised not to use the toolchain sysroot directory as an

install directory for your programs/packages. If you do so, you will not be

able to use your toolchain for another project. It is even strongly advised

that your toolchain is chmod-ed to read-only once successfully build, so that

you don't go polluting your toolchain with your programs/packages' files.

Thus, when you build a program/package, install it in a separate directory,

eg. /your/root. This directory is the /image/ of what would be in the root file

system of your target, and will contain all that your programs/packages have

installed.

The 'populate' script |

----------------------+

When your root directory is ready, it is still missing some important bits: the

toolchain's libraries. To populate your root directory with those libs, just

run:

  your-target-tuple-populate -s /your/root -d /your/root-populated

This will copy /your/root into /your/root-populated, and put the needed and only

the needed libraries there. Thus you don't pollute /your/root with any cruft that

would no longer be needed should you have to remove stuff. /your/root always

contains only those things you install in it.

You can then use /your/root-populated to build up your file system image, a

tarball, or to NFS-mount it from your target, or whatever you need.

The populate script accepts the following options:

 -s src_dir

    Use 'src_dir' as the un-populated root directory.

 -d dst_dir

    Put the populated root directory in 'dst_dir'.

 -l lib1 [...]

    Always add specified libraries.

 -L file

    Always add libraries listed in 'file'.

 -f

    Remove 'dst_dir' if it previously existed; continue even if any library

    specified with -l or -L is missing.

 -v

    Be verbose, and tell what's going on (you can see exactly where libs are

    coming from).

 -h

    Print the help.

See 'your-target-tuple-populate -h' for more information on the options.

Here is how populate works:

  1) performs some sanity checks:

     - src_dir and dst_dir are specified

     - src_dir exists

     - unless forced, dst_dir does not exist

     - src_dir != dst_dir

  2) copy src_dir to dst_dir

  3) add forced libraries to dst_dir

     - build the list from -l and -L options

     - get forced libraries from the sysroot (see below for heuristics)

       - abort on the first missing library, unless -f is specified

  4) add all missing libraries to dst_dir

     - scan dst_dir for every ELF files that are 'executable' or

       'shared object'

     - list the "NEEDED Shared library" fields

       - check if the library is already in dst_dir/lib or dst_dir/usr/lib

       - if not, get the library from the sysroot

         - if it's in sysroot/lib, copy it to dst_dir/lib

         - if it's in sysroot/usr/lib, copy it to dst_dir/usr/lib

         - in both cases, use the SONAME of the library to create the file

           in dst_dir

         - if it was not found in the sysroot, this is an error.