Merge tag 'nfsd-5.13-1' of git://git.kernel.org/pub/scm/linux/kernel/git/cel/linux
[platform/kernel/linux-rpi.git] / scripts / link-vmlinux.sh
1 #!/bin/sh
2 # SPDX-License-Identifier: GPL-2.0
3 #
4 # link vmlinux
5 #
6 # vmlinux is linked from the objects selected by $(KBUILD_VMLINUX_OBJS) and
7 # $(KBUILD_VMLINUX_LIBS). Most are built-in.a files from top-level directories
8 # in the kernel tree, others are specified in arch/$(ARCH)/Makefile.
9 # $(KBUILD_VMLINUX_LIBS) are archives which are linked conditionally
10 # (not within --whole-archive), and do not require symbol indexes added.
11 #
12 # vmlinux
13 #   ^
14 #   |
15 #   +--< $(KBUILD_VMLINUX_OBJS)
16 #   |    +--< init/built-in.a drivers/built-in.a mm/built-in.a + more
17 #   |
18 #   +--< $(KBUILD_VMLINUX_LIBS)
19 #   |    +--< lib/lib.a + more
20 #   |
21 #   +-< ${kallsymso} (see description in KALLSYMS section)
22 #
23 # vmlinux version (uname -v) cannot be updated during normal
24 # descending-into-subdirs phase since we do not yet know if we need to
25 # update vmlinux.
26 # Therefore this step is delayed until just before final link of vmlinux.
27 #
28 # System.map is generated to document addresses of all kernel symbols
29
30 # Error out on error
31 set -e
32
33 LD="$1"
34 KBUILD_LDFLAGS="$2"
35 LDFLAGS_vmlinux="$3"
36
37 # Nice output in kbuild format
38 # Will be supressed by "make -s"
39 info()
40 {
41         if [ "${quiet}" != "silent_" ]; then
42                 printf "  %-7s %s\n" "${1}" "${2}"
43         fi
44 }
45
46 # Generate a linker script to ensure correct ordering of initcalls.
47 gen_initcalls()
48 {
49         info GEN .tmp_initcalls.lds
50
51         ${PYTHON} ${srctree}/scripts/jobserver-exec             \
52         ${PERL} ${srctree}/scripts/generate_initcall_order.pl   \
53                 ${KBUILD_VMLINUX_OBJS} ${KBUILD_VMLINUX_LIBS}   \
54                 > .tmp_initcalls.lds
55 }
56
57 # If CONFIG_LTO_CLANG is selected, collect generated symbol versions into
58 # .tmp_symversions.lds
59 gen_symversions()
60 {
61         info GEN .tmp_symversions.lds
62         rm -f .tmp_symversions.lds
63
64         for o in ${KBUILD_VMLINUX_OBJS} ${KBUILD_VMLINUX_LIBS}; do
65                 if [ -f ${o}.symversions ]; then
66                         cat ${o}.symversions >> .tmp_symversions.lds
67                 fi
68         done
69 }
70
71 # Link of vmlinux.o used for section mismatch analysis
72 # ${1} output file
73 modpost_link()
74 {
75         local objects
76         local lds=""
77
78         objects="--whole-archive                                \
79                 ${KBUILD_VMLINUX_OBJS}                          \
80                 --no-whole-archive                              \
81                 --start-group                                   \
82                 ${KBUILD_VMLINUX_LIBS}                          \
83                 --end-group"
84
85         if [ -n "${CONFIG_LTO_CLANG}" ]; then
86                 gen_initcalls
87                 lds="-T .tmp_initcalls.lds"
88
89                 if [ -n "${CONFIG_MODVERSIONS}" ]; then
90                         gen_symversions
91                         lds="${lds} -T .tmp_symversions.lds"
92                 fi
93
94                 # This might take a while, so indicate that we're doing
95                 # an LTO link
96                 info LTO ${1}
97         else
98                 info LD ${1}
99         fi
100
101         ${LD} ${KBUILD_LDFLAGS} -r -o ${1} ${lds} ${objects}
102 }
103
104 objtool_link()
105 {
106         local objtoolcmd;
107         local objtoolopt;
108
109         if [ "${CONFIG_LTO_CLANG} ${CONFIG_STACK_VALIDATION}" = "y y" ]; then
110                 # Don't perform vmlinux validation unless explicitly requested,
111                 # but run objtool on vmlinux.o now that we have an object file.
112                 if [ -n "${CONFIG_UNWINDER_ORC}" ]; then
113                         objtoolcmd="orc generate"
114                 fi
115
116                 objtoolopt="${objtoolopt} --duplicate"
117
118                 if [ -n "${CONFIG_FTRACE_MCOUNT_USE_OBJTOOL}" ]; then
119                         objtoolopt="${objtoolopt} --mcount"
120                 fi
121         fi
122
123         if [ -n "${CONFIG_VMLINUX_VALIDATION}" ]; then
124                 objtoolopt="${objtoolopt} --noinstr"
125         fi
126
127         if [ -n "${objtoolopt}" ]; then
128                 if [ -z "${objtoolcmd}" ]; then
129                         objtoolcmd="check"
130                 fi
131                 objtoolopt="${objtoolopt} --vmlinux"
132                 if [ -z "${CONFIG_FRAME_POINTER}" ]; then
133                         objtoolopt="${objtoolopt} --no-fp"
134                 fi
135                 if [ -n "${CONFIG_GCOV_KERNEL}" ] || [ -n "${CONFIG_LTO_CLANG}" ]; then
136                         objtoolopt="${objtoolopt} --no-unreachable"
137                 fi
138                 if [ -n "${CONFIG_RETPOLINE}" ]; then
139                         objtoolopt="${objtoolopt} --retpoline"
140                 fi
141                 if [ -n "${CONFIG_X86_SMAP}" ]; then
142                         objtoolopt="${objtoolopt} --uaccess"
143                 fi
144                 info OBJTOOL ${1}
145                 tools/objtool/objtool ${objtoolcmd} ${objtoolopt} ${1}
146         fi
147 }
148
149 # Link of vmlinux
150 # ${1} - output file
151 # ${2}, ${3}, ... - optional extra .o files
152 vmlinux_link()
153 {
154         local lds="${objtree}/${KBUILD_LDS}"
155         local output=${1}
156         local objects
157         local strip_debug
158         local map_option
159
160         info LD ${output}
161
162         # skip output file argument
163         shift
164
165         # The kallsyms linking does not need debug symbols included.
166         if [ "$output" != "${output#.tmp_vmlinux.kallsyms}" ] ; then
167                 strip_debug=-Wl,--strip-debug
168         fi
169
170         if [ -n "${CONFIG_VMLINUX_MAP}" ]; then
171                 map_option="-Map=${output}.map"
172         fi
173
174         if [ "${SRCARCH}" != "um" ]; then
175                 if [ -n "${CONFIG_LTO_CLANG}" ]; then
176                         # Use vmlinux.o instead of performing the slow LTO
177                         # link again.
178                         objects="--whole-archive                \
179                                 vmlinux.o                       \
180                                 --no-whole-archive              \
181                                 ${@}"
182                 else
183                         objects="--whole-archive                \
184                                 ${KBUILD_VMLINUX_OBJS}          \
185                                 --no-whole-archive              \
186                                 --start-group                   \
187                                 ${KBUILD_VMLINUX_LIBS}          \
188                                 --end-group                     \
189                                 ${@}"
190                 fi
191
192                 ${LD} ${KBUILD_LDFLAGS} ${LDFLAGS_vmlinux}      \
193                         ${strip_debug#-Wl,}                     \
194                         -o ${output}                            \
195                         ${map_option}                           \
196                         -T ${lds} ${objects}
197         else
198                 objects="-Wl,--whole-archive                    \
199                         ${KBUILD_VMLINUX_OBJS}                  \
200                         -Wl,--no-whole-archive                  \
201                         -Wl,--start-group                       \
202                         ${KBUILD_VMLINUX_LIBS}                  \
203                         -Wl,--end-group                         \
204                         ${@}"
205
206                 ${CC} ${CFLAGS_vmlinux}                         \
207                         ${strip_debug}                          \
208                         -o ${output}                            \
209                         ${map_option:+-Wl,${map_option}}        \
210                         -Wl,-T,${lds}                           \
211                         ${objects}                              \
212                         -lutil -lrt -lpthread
213                 rm -f linux
214         fi
215 }
216
217 # generate .BTF typeinfo from DWARF debuginfo
218 # ${1} - vmlinux image
219 # ${2} - file to dump raw BTF data into
220 gen_btf()
221 {
222         local pahole_ver
223         local extra_paholeopt=
224
225         if ! [ -x "$(command -v ${PAHOLE})" ]; then
226                 echo >&2 "BTF: ${1}: pahole (${PAHOLE}) is not available"
227                 return 1
228         fi
229
230         pahole_ver=$(${PAHOLE} --version | sed -E 's/v([0-9]+)\.([0-9]+)/\1\2/')
231         if [ "${pahole_ver}" -lt "116" ]; then
232                 echo >&2 "BTF: ${1}: pahole version $(${PAHOLE} --version) is too old, need at least v1.16"
233                 return 1
234         fi
235
236         vmlinux_link ${1}
237
238         if [ "${pahole_ver}" -ge "121" ]; then
239                 extra_paholeopt="${extra_paholeopt} --btf_gen_floats"
240         fi
241
242         info "BTF" ${2}
243         LLVM_OBJCOPY=${OBJCOPY} ${PAHOLE} -J ${extra_paholeopt} ${1}
244
245         # Create ${2} which contains just .BTF section but no symbols. Add
246         # SHF_ALLOC because .BTF will be part of the vmlinux image. --strip-all
247         # deletes all symbols including __start_BTF and __stop_BTF, which will
248         # be redefined in the linker script. Add 2>/dev/null to suppress GNU
249         # objcopy warnings: "empty loadable segment detected at ..."
250         ${OBJCOPY} --only-section=.BTF --set-section-flags .BTF=alloc,readonly \
251                 --strip-all ${1} ${2} 2>/dev/null
252         # Change e_type to ET_REL so that it can be used to link final vmlinux.
253         # Unlike GNU ld, lld does not allow an ET_EXEC input.
254         printf '\1' | dd of=${2} conv=notrunc bs=1 seek=16 status=none
255 }
256
257 # Create ${2} .S file with all symbols from the ${1} object file
258 kallsyms()
259 {
260         local kallsymopt;
261
262         if [ -n "${CONFIG_KALLSYMS_ALL}" ]; then
263                 kallsymopt="${kallsymopt} --all-symbols"
264         fi
265
266         if [ -n "${CONFIG_KALLSYMS_ABSOLUTE_PERCPU}" ]; then
267                 kallsymopt="${kallsymopt} --absolute-percpu"
268         fi
269
270         if [ -n "${CONFIG_KALLSYMS_BASE_RELATIVE}" ]; then
271                 kallsymopt="${kallsymopt} --base-relative"
272         fi
273
274         info KSYMS ${2}
275         ${NM} -n ${1} | scripts/kallsyms ${kallsymopt} > ${2}
276 }
277
278 # Perform one step in kallsyms generation, including temporary linking of
279 # vmlinux.
280 kallsyms_step()
281 {
282         kallsymso_prev=${kallsymso}
283         kallsyms_vmlinux=.tmp_vmlinux.kallsyms${1}
284         kallsymso=${kallsyms_vmlinux}.o
285         kallsyms_S=${kallsyms_vmlinux}.S
286
287         vmlinux_link ${kallsyms_vmlinux} "${kallsymso_prev}" ${btf_vmlinux_bin_o}
288         kallsyms ${kallsyms_vmlinux} ${kallsyms_S}
289
290         info AS ${kallsyms_S}
291         ${CC} ${NOSTDINC_FLAGS} ${LINUXINCLUDE} ${KBUILD_CPPFLAGS} \
292               ${KBUILD_AFLAGS} ${KBUILD_AFLAGS_KERNEL} \
293               -c -o ${kallsymso} ${kallsyms_S}
294 }
295
296 # Create map file with all symbols from ${1}
297 # See mksymap for additional details
298 mksysmap()
299 {
300         ${CONFIG_SHELL} "${srctree}/scripts/mksysmap" ${1} ${2}
301 }
302
303 sorttable()
304 {
305         ${objtree}/scripts/sorttable ${1}
306 }
307
308 # Delete output files in case of error
309 cleanup()
310 {
311         rm -f .btf.*
312         rm -f .tmp_System.map
313         rm -f .tmp_initcalls.lds
314         rm -f .tmp_symversions.lds
315         rm -f .tmp_vmlinux*
316         rm -f System.map
317         rm -f vmlinux
318         rm -f vmlinux.map
319         rm -f vmlinux.o
320         rm -f .vmlinux.d
321 }
322
323 on_exit()
324 {
325         if [ $? -ne 0 ]; then
326                 cleanup
327         fi
328 }
329 trap on_exit EXIT
330
331 on_signals()
332 {
333         exit 1
334 }
335 trap on_signals HUP INT QUIT TERM
336
337 # Use "make V=1" to debug this script
338 case "${KBUILD_VERBOSE}" in
339 *1*)
340         set -x
341         ;;
342 esac
343
344 if [ "$1" = "clean" ]; then
345         cleanup
346         exit 0
347 fi
348
349 # We need access to CONFIG_ symbols
350 . include/config/auto.conf
351
352 # Update version
353 info GEN .version
354 if [ -r .version ]; then
355         VERSION=$(expr 0$(cat .version) + 1)
356         echo $VERSION > .version
357 else
358         rm -f .version
359         echo 1 > .version
360 fi;
361
362 # final build of init/
363 ${MAKE} -f "${srctree}/scripts/Makefile.build" obj=init need-builtin=1
364
365 #link vmlinux.o
366 modpost_link vmlinux.o
367 objtool_link vmlinux.o
368
369 # modpost vmlinux.o to check for section mismatches
370 ${MAKE} -f "${srctree}/scripts/Makefile.modpost" MODPOST_VMLINUX=1
371
372 info MODINFO modules.builtin.modinfo
373 ${OBJCOPY} -j .modinfo -O binary vmlinux.o modules.builtin.modinfo
374 info GEN modules.builtin
375 # The second line aids cases where multiple modules share the same object.
376 tr '\0' '\n' < modules.builtin.modinfo | sed -n 's/^[[:alnum:]:_]*\.file=//p' |
377         tr ' ' '\n' | uniq | sed -e 's:^:kernel/:' -e 's/$/.ko/' > modules.builtin
378
379 btf_vmlinux_bin_o=""
380 if [ -n "${CONFIG_DEBUG_INFO_BTF}" ]; then
381         btf_vmlinux_bin_o=.btf.vmlinux.bin.o
382         if ! gen_btf .tmp_vmlinux.btf $btf_vmlinux_bin_o ; then
383                 echo >&2 "Failed to generate BTF for vmlinux"
384                 echo >&2 "Try to disable CONFIG_DEBUG_INFO_BTF"
385                 exit 1
386         fi
387 fi
388
389 kallsymso=""
390 kallsymso_prev=""
391 kallsyms_vmlinux=""
392 if [ -n "${CONFIG_KALLSYMS}" ]; then
393
394         # kallsyms support
395         # Generate section listing all symbols and add it into vmlinux
396         # It's a three step process:
397         # 1)  Link .tmp_vmlinux1 so it has all symbols and sections,
398         #     but __kallsyms is empty.
399         #     Running kallsyms on that gives us .tmp_kallsyms1.o with
400         #     the right size
401         # 2)  Link .tmp_vmlinux2 so it now has a __kallsyms section of
402         #     the right size, but due to the added section, some
403         #     addresses have shifted.
404         #     From here, we generate a correct .tmp_kallsyms2.o
405         # 3)  That link may have expanded the kernel image enough that
406         #     more linker branch stubs / trampolines had to be added, which
407         #     introduces new names, which further expands kallsyms. Do another
408         #     pass if that is the case. In theory it's possible this results
409         #     in even more stubs, but unlikely.
410         #     KALLSYMS_EXTRA_PASS=1 may also used to debug or work around
411         #     other bugs.
412         # 4)  The correct ${kallsymso} is linked into the final vmlinux.
413         #
414         # a)  Verify that the System.map from vmlinux matches the map from
415         #     ${kallsymso}.
416
417         kallsyms_step 1
418         kallsyms_step 2
419
420         # step 3
421         size1=$(${CONFIG_SHELL} "${srctree}/scripts/file-size.sh" ${kallsymso_prev})
422         size2=$(${CONFIG_SHELL} "${srctree}/scripts/file-size.sh" ${kallsymso})
423
424         if [ $size1 -ne $size2 ] || [ -n "${KALLSYMS_EXTRA_PASS}" ]; then
425                 kallsyms_step 3
426         fi
427 fi
428
429 vmlinux_link vmlinux "${kallsymso}" ${btf_vmlinux_bin_o}
430
431 # fill in BTF IDs
432 if [ -n "${CONFIG_DEBUG_INFO_BTF}" -a -n "${CONFIG_BPF}" ]; then
433         info BTFIDS vmlinux
434         ${RESOLVE_BTFIDS} vmlinux
435 fi
436
437 if [ -n "${CONFIG_BUILDTIME_TABLE_SORT}" ]; then
438         info SORTTAB vmlinux
439         if ! sorttable vmlinux; then
440                 echo >&2 Failed to sort kernel tables
441                 exit 1
442         fi
443 fi
444
445 info SYSMAP System.map
446 mksysmap vmlinux System.map
447
448 # step a (see comment above)
449 if [ -n "${CONFIG_KALLSYMS}" ]; then
450         mksysmap ${kallsyms_vmlinux} .tmp_System.map
451
452         if ! cmp -s System.map .tmp_System.map; then
453                 echo >&2 Inconsistent kallsyms data
454                 echo >&2 Try "make KALLSYMS_EXTRA_PASS=1" as a workaround
455                 exit 1
456         fi
457 fi
458
459 # For fixdep
460 echo "vmlinux: $0" > .vmlinux.d