1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
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.
|
