Re: [PATCH v10 2/4] kbuild: generate offset range data for builtin modules

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Fri, Sep 06, 2024 at 10:45:03AM -0400, Kris Van Hees wrote:
> Create file module.builtin.ranges that can be used to find where
> built-in modules are located by their addresses. This will be useful for
> tracing tools to find what functions are for various built-in modules.
> 
> The offset range data for builtin modules is generated using:
>  - modules.builtin: associates object files with module names
>  - vmlinux.map: provides load order of sections and offset of first member
>     per section
>  - vmlinux.o.map: provides offset of object file content per section
>  - .*.cmd: build cmd file with KBUILD_MODFILE
> 
> The generated data will look like:
> 
> .text 00000000-00000000 = _text
> .text 0000baf0-0000cb10 amd_uncore
> .text 0009bd10-0009c8e0 iosf_mbi
> ...
> .text 00b9f080-00ba011a intel_skl_int3472_discrete
> .text 00ba0120-00ba03c0 intel_skl_int3472_discrete intel_skl_int3472_tps68470
> .text 00ba03c0-00ba08d6 intel_skl_int3472_tps68470
> ...
> .data 00000000-00000000 = _sdata
> .data 0000f020-0000f680 amd_uncore
> 
> For each ELF section, it lists the offset of the first symbol.  This can
> be used to determine the base address of the section at runtime.
> 
> Next, it lists (in strict ascending order) offset ranges in that section
> that cover the symbols of one or more builtin modules.  Multiple ranges
> can apply to a single module, and ranges can be shared between modules.
> 
> The CONFIG_BUILTIN_MODULE_RANGES option controls whether offset range data
> is generated for kernel modules that are built into the kernel image.
> 
> How it works:
> 
>  1. The modules.builtin file is parsed to obtain a list of built-in
>     module names and their associated object names (the .ko file that
>     the module would be in if it were a loadable module, hereafter
>     referred to as <kmodfile>).  This object name can be used to
>     identify objects in the kernel compile because any C or assembler
>     code that ends up into a built-in module will have the option
>     -DKBUILD_MODFILE=<kmodfile> present in its build command, and those
>     can be found in the .<obj>.cmd file in the kernel build tree.
> 
>     If an object is part of multiple modules, they will all be listed
>     in the KBUILD_MODFILE option argument.
> 
>     This allows us to conclusively determine whether an object in the
>     kernel build belong to any modules, and which.
> 
>  2. The vmlinux.map is parsed next to determine the base address of each
>     top level section so that all addresses into the section can be
>     turned into offsets.  This makes it possible to handle sections
>     getting loaded at different addresses at system boot.
> 
>     We also determine an 'anchor' symbol at the beginning of each
>     section to make it possible to calculate the true base address of
>     a section at runtime (i.e. symbol address - symbol offset).
> 
>     We collect start addresses of sections that are included in the top
>     level section.  This is used when vmlinux is linked using vmlinux.o,
>     because in that case, we need to look at the vmlinux.o linker map to
>     know what object a symbol is found in.
> 
>     And finally, we process each symbol that is listed in vmlinux.map
>     (or vmlinux.o.map) based on the following structure:
> 
>     vmlinux linked from vmlinux.a:
> 
>       vmlinux.map:
>         <top level section>
>           <included section>  -- might be same as top level section)
>             <object>          -- built-in association known
>               <symbol>        -- belongs to module(s) object belongs to
>               ...
> 
>     vmlinux linked from vmlinux.o:
> 
>       vmlinux.map:
>         <top level section>
>           <included section>  -- might be same as top level section)
>             vmlinux.o         -- need to use vmlinux.o.map
>               <symbol>        -- ignored
>               ...
> 
>       vmlinux.o.map:
>         <section>
>             <object>          -- built-in association known
>               <symbol>        -- belongs to module(s) object belongs to
>               ...
> 
>  3. As sections, objects, and symbols are processed, offset ranges are
>     constructed in a straight-forward way:
> 
>       - If the symbol belongs to one or more built-in modules:
>           - If we were working on the same module(s), extend the range
>             to include this object
>           - If we were working on another module(s), close that range,
>             and start the new one
>       - If the symbol does not belong to any built-in modules:
>           - If we were working on a module(s) range, close that range
> 
> Signed-off-by: Kris Van Hees <kris.van.hees@xxxxxxxxxx>
> Reviewed-by: Nick Alcock <nick.alcock@xxxxxxxxxx>
> Reviewed-by: Alan Maguire <alan.maguire@xxxxxxxxxx>
> Reviewed-by: Steven Rostedt (Google) <rostedt@xxxxxxxxxxx>
> Tested-by: Sam James <sam@xxxxxxxxxx>
> ---
> 
> Notes:
>     Changes since v9:
>      - Reverted support for build directory as optional 4th argument.
>      - Added modules.builtin.ranges and vmlinux.o.map to CLEAN_FILES.
>      - Fixed support for sparc64.
>     
>     Changes since v8:
>      - Added support for built-in Rust modules.
>      - Added optional 4th argument to specify kernel build directory.
>     
>     Changes since v7:
>      - Removed extra close(fn).
>      - Make CONFIG_BUILTIN_MODULE_RANGES depend on !lTO.
>     
>     Changes since v6:
>      - Applied Masahiro Yamada's suggestions (Kconfig, makefile, script).
>     
>     Changes since v5:
>      - Removed unnecessary compatibility info from option description.
>     
>     Changes since v4:
>      - Improved commit description to explain the why and how.
>      - Documented dependency on GNU AWK for CONFIG_BUILTIN_MODULE_RANGES.
>      - Improved comments in generate_builtin_ranges.awk
>      - Improved logic in generate_builtin_ranges.awk to handle incorrect
>        object size information in linker maps
>     
>     Changes since v3:
>      - Consolidated patches 2 through 5 into a single patch
>      - Move CONFIG_BUILTIN_MODULE_RANGES to Kconfig.debug
>      - Make CONFIG_BUILTIN_MODULE_RANGES select CONFIG_VMLINUX_MAP
>      - Disable CONFIG_BUILTIN_MODULE_RANGES if CONFIG_LTO_CLANG_(FULL|THIN)=y
>      - Support LLVM (lld) compiles in generate_builtin_ranges.awk
>      - Support CONFIG_LD_DEAD_CODE_DATA_ELIMINATION=y
>     
>     Changes since v2:
>      - Add explicit dependency on FTRACE for CONFIG_BUILTIN_MODULE_RANGES
>      - 1st arg to generate_builtin_ranges.awk is now modules.builtin.modinfo
>      - Switched from using modules.builtin.objs to parsing .*.cmd files
>      - Parse data from .*.cmd in generate_builtin_ranges.awk
>      - Use $(real-prereqs) rather than $(filter-out ...)
>     ---
> 
>  Documentation/process/changes.rst   |   7 +
>  Makefile                            |   1 +
>  lib/Kconfig.debug                   |  15 +
>  scripts/Makefile.vmlinux            |  18 +
>  scripts/Makefile.vmlinux_o          |   3 +
>  scripts/generate_builtin_ranges.awk | 508 ++++++++++++++++++++++++++++
>  6 files changed, 552 insertions(+)
>  create mode 100755 scripts/generate_builtin_ranges.awk
> 
> diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst
> index 3fc63f27c226..00f1ed7c59c3 100644
> --- a/Documentation/process/changes.rst
> +++ b/Documentation/process/changes.rst
> @@ -64,6 +64,7 @@ GNU tar                1.28             tar --version
>  gtags (optional)       6.6.5            gtags --version
>  mkimage (optional)     2017.01          mkimage --version
>  Python (optional)      3.5.x            python3 --version
> +GNU AWK (optional)     5.1.0            gawk --version
>  ====================== ===============  ========================================
>  
>  .. [#f1] Sphinx is needed only to build the Kernel documentation
> @@ -192,6 +193,12 @@ platforms. The tool is available via the ``u-boot-tools`` package or can be
>  built from the U-Boot source code. See the instructions at
>  https://docs.u-boot.org/en/latest/build/tools.html#building-tools-for-linux
>  
> +GNU AWK
> +-------
> +
> +GNU AWK is needed if you want kernel builds to generate address range data for
> +builtin modules (CONFIG_BUILTIN_MODULE_RANGES).
> +
>  System utilities
>  ****************
>  
> diff --git a/Makefile b/Makefile
> index d57cfc6896b8..ec98a1e5b257 100644
> --- a/Makefile
> +++ b/Makefile
> @@ -1482,6 +1482,7 @@ endif # CONFIG_MODULES
>  # Directories & files removed with 'make clean'
>  CLEAN_FILES += vmlinux.symvers modules-only.symvers \
>  	       modules.builtin modules.builtin.modinfo modules.nsdeps \
> +	       modules.builtin.ranges vmlinux.o.map \
>  	       compile_commands.json rust/test \
>  	       rust-project.json .vmlinux.objs .vmlinux.export.c
>  
> diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
> index a30c03a66172..5e2f30921cb2 100644
> --- a/lib/Kconfig.debug
> +++ b/lib/Kconfig.debug
> @@ -571,6 +571,21 @@ config VMLINUX_MAP
>  	  pieces of code get eliminated with
>  	  CONFIG_LD_DEAD_CODE_DATA_ELIMINATION.
>  
> +config BUILTIN_MODULE_RANGES
> +	bool "Generate address range information for builtin modules"
> +	depends on !LTO
> +	depends on VMLINUX_MAP
> +	help
> +	 When modules are built into the kernel, there will be no module name
> +	 associated with its symbols in /proc/kallsyms.  Tracers may want to
> +	 identify symbols by module name and symbol name regardless of whether
> +	 the module is configured as loadable or not.
> +
> +	 This option generates modules.builtin.ranges in the build tree with
> +	 offset ranges (per ELF section) for the module(s) they belong to.
> +	 It also records an anchor symbol to determine the load address of the
> +	 section.
> +
>  config DEBUG_FORCE_WEAK_PER_CPU
>  	bool "Force weak per-cpu definitions"
>  	depends on DEBUG_KERNEL
> diff --git a/scripts/Makefile.vmlinux b/scripts/Makefile.vmlinux
> index 5ceecbed31eb..dfb408aa19c6 100644
> --- a/scripts/Makefile.vmlinux
> +++ b/scripts/Makefile.vmlinux
> @@ -33,6 +33,24 @@ targets += vmlinux
>  vmlinux: scripts/link-vmlinux.sh vmlinux.o $(KBUILD_LDS) FORCE
>  	+$(call if_changed_dep,link_vmlinux)
>  
> +# module.builtin.ranges
> +# ---------------------------------------------------------------------------
> +ifdef CONFIG_BUILTIN_MODULE_RANGES
> +__default: modules.builtin.ranges
> +
> +quiet_cmd_modules_builtin_ranges = GEN     $@
> +      cmd_modules_builtin_ranges = $(real-prereqs) > $@
> +
> +targets += modules.builtin.ranges
> +modules.builtin.ranges: $(srctree)/scripts/generate_builtin_ranges.awk \
> +			modules.builtin vmlinux.map vmlinux.o.map FORCE
> +	$(call if_changed,modules_builtin_ranges)
> +
> +vmlinux.map: vmlinux
> +	@:
> +
> +endif
> +
>  # Add FORCE to the prerequisites of a target to force it to be always rebuilt.
>  # ---------------------------------------------------------------------------
>  
> diff --git a/scripts/Makefile.vmlinux_o b/scripts/Makefile.vmlinux_o
> index d64070b6b4bc..0b6e2ebf60dc 100644
> --- a/scripts/Makefile.vmlinux_o
> +++ b/scripts/Makefile.vmlinux_o
> @@ -45,9 +45,12 @@ objtool-args = $(vmlinux-objtool-args-y) --link
>  # Link of vmlinux.o used for section mismatch analysis
>  # ---------------------------------------------------------------------------
>  
> +vmlinux-o-ld-args-$(CONFIG_BUILTIN_MODULE_RANGES)	+= -Map=$@.map
> +
>  quiet_cmd_ld_vmlinux.o = LD      $@
>        cmd_ld_vmlinux.o = \
>  	$(LD) ${KBUILD_LDFLAGS} -r -o $@ \
> +	$(vmlinux-o-ld-args-y) \
>  	$(addprefix -T , $(initcalls-lds)) \
>  	--whole-archive vmlinux.a --no-whole-archive \
>  	--start-group $(KBUILD_VMLINUX_LIBS) --end-group \
> diff --git a/scripts/generate_builtin_ranges.awk b/scripts/generate_builtin_ranges.awk
> new file mode 100755
> index 000000000000..b9ec761b3bef
> --- /dev/null
> +++ b/scripts/generate_builtin_ranges.awk
> @@ -0,0 +1,508 @@
> +#!/usr/bin/gawk -f

This forces the gawk to be found always in /usr/bin. For systems where gawk can
be located in other places, can we change the Shebang to:

diff --git a/scripts/generate_builtin_ranges.awk b/scripts/generate_builtin_ranges.awk
index b9ec761b3bef..886251c8d3f7 100755
--- a/scripts/generate_builtin_ranges.awk
+++ b/scripts/generate_builtin_ranges.awk
@@ -1,4 +1,4 @@
-#!/usr/bin/gawk -f
+#!/usr/bin/env gawk -f
 # SPDX-License-Identifier: GPL-2.0
 # generate_builtin_ranges.awk: Generate address range data for builtin modules
 # Written by Kris Van Hees <kris.van.hees@xxxxxxxxxx>

Not sure if it's too late? in that case I can send a patch to change this.


Daniel


> +# SPDX-License-Identifier: GPL-2.0
> +# generate_builtin_ranges.awk: Generate address range data for builtin modules
> +# Written by Kris Van Hees <kris.van.hees@xxxxxxxxxx>
> +#
> +# Usage: generate_builtin_ranges.awk modules.builtin vmlinux.map \
> +#		vmlinux.o.map > modules.builtin.ranges
> +#
> +
> +# Return the module name(s) (if any) associated with the given object.
> +#
> +# If we have seen this object before, return information from the cache.
> +# Otherwise, retrieve it from the corresponding .cmd file.
> +#
> +function get_module_info(fn, mod, obj, s) {
> +	if (fn in omod)
> +		return omod[fn];
> +
> +	if (match(fn, /\/[^/]+$/) == 0)
> +		return "";
> +
> +	obj = fn;
> +	mod = "";
> +	fn = substr(fn, 1, RSTART) "." substr(fn, RSTART + 1) ".cmd";
> +	if (getline s <fn == 1) {
> +		if (match(s, /DKBUILD_MODFILE=['"]+[^'"]+/) > 0) {
> +			mod = substr(s, RSTART + 16, RLENGTH - 16);
> +			gsub(/['"]/, "", mod);
> +		} else if (match(s, /RUST_MODFILE=[^ ]+/) > 0)
> +			mod = substr(s, RSTART + 13, RLENGTH - 13);
> +	}
> +	close(fn);
> +
> +	# A single module (common case) also reflects objects that are not part
> +	# of a module.  Some of those objects have names that are also a module
> +	# name (e.g. core).  We check the associated module file name, and if
> +	# they do not match, the object is not part of a module.
> +	if (mod !~ / /) {
> +		if (!(mod in mods))
> +			mod = "";
> +	}
> +
> +	gsub(/([^/ ]*\/)+/, "", mod);
> +	gsub(/-/, "_", mod);
> +
> +	# At this point, mod is a single (valid) module name, or a list of
> +	# module names (that do not need validation).
> +	omod[obj] = mod;
> +
> +	return mod;
> +}
> +
> +# Update the ranges entry for the given module 'mod' in section 'osect'.
> +#
> +# We use a modified absolute start address (soff + base) as index because we
> +# may need to insert an anchor record later that must be at the start of the
> +# section data, and the first module may very well start at the same address.
> +# So, we use (addr << 1) + 1 to allow a possible anchor record to be placed at
> +# (addr << 1).  This is safe because the index is only used to sort the entries
> +# before writing them out.
> +#
> +function update_entry(osect, mod, soff, eoff, sect, idx) {
> +	sect = sect_in[osect];
> +	idx = sprintf("%016x", (soff + sect_base[osect]) * 2 + 1);
> +	entries[idx] = sprintf("%s %08x-%08x %s", sect, soff, eoff, mod);
> +	count[sect]++;
> +}
> +
> +# (1) Build a lookup map of built-in module names.
> +#
> +# The first file argument is used as input (modules.builtin).
> +#
> +# Lines will be like:
> +#	kernel/crypto/lzo-rle.ko
> +# and we record the object name "crypto/lzo-rle".
> +#
> +ARGIND == 1 {
> +	sub(/kernel\//, "");			# strip off "kernel/" prefix
> +	sub(/\.ko$/, "");			# strip off .ko suffix
> +
> +	mods[$1] = 1;
> +	next;
> +}
> +
> +# (2) Collect address information for each section.
> +#
> +# The second file argument is used as input (vmlinux.map).
> +#
> +# We collect the base address of the section in order to convert all addresses
> +# in the section into offset values.
> +#
> +# We collect the address of the anchor (or first symbol in the section if there
> +# is no explicit anchor) to allow users of the range data to calculate address
> +# ranges based on the actual load address of the section in the running kernel.
> +#
> +# We collect the start address of any sub-section (section included in the top
> +# level section being processed).  This is needed when the final linking was
> +# done using vmlinux.a because then the list of objects contained in each
> +# section is to be obtained from vmlinux.o.map.  The offset of the sub-section
> +# is recorded here, to be used as an addend when processing vmlinux.o.map
> +# later.
> +#
> +
> +# Both GNU ld and LLVM lld linker map format are supported by converting LLVM
> +# lld linker map records into equivalent GNU ld linker map records.
> +#
> +# The first record of the vmlinux.map file provides enough information to know
> +# which format we are dealing with.
> +#
> +ARGIND == 2 && FNR == 1 && NF == 7 && $1 == "VMA" && $7 == "Symbol" {
> +	map_is_lld = 1;
> +	if (dbg)
> +		printf "NOTE: %s uses LLVM lld linker map format\n", FILENAME >"/dev/stderr";
> +	next;
> +}
> +
> +# (LLD) Convert a section record fronm lld format to ld format.
> +#
> +# lld: ffffffff82c00000          2c00000   2493c0  8192 .data
> +#  ->
> +# ld:  .data           0xffffffff82c00000   0x2493c0 load address 0x0000000002c00000
> +#
> +ARGIND == 2 && map_is_lld && NF == 5 && /[0-9] [^ ]+$/ {
> +	$0 = $5 " 0x"$1 " 0x"$3 " load address 0x"$2;
> +}
> +
> +# (LLD) Convert an anchor record from lld format to ld format.
> +#
> +# lld: ffffffff81000000          1000000        0     1         _text = .
> +#  ->
> +# ld:                  0xffffffff81000000                _text = .
> +#
> +ARGIND == 2 && map_is_lld && !anchor && NF == 7 && raw_addr == "0x"$1 && $6 == "=" && $7 == "." {
> +	$0 = "  0x"$1 " " $5 " = .";
> +}
> +
> +# (LLD) Convert an object record from lld format to ld format.
> +#
> +# lld:            11480            11480     1f07    16         vmlinux.a(arch/x86/events/amd/uncore.o):(.text)
> +#  ->
> +# ld:   .text          0x0000000000011480     0x1f07 arch/x86/events/amd/uncore.o
> +#
> +ARGIND == 2 && map_is_lld && NF == 5 && $5 ~ /:\(/ {
> +	gsub(/\)/, "");
> +	sub(/ vmlinux\.a\(/, " ");
> +	sub(/:\(/, " ");
> +	$0 = " "$6 " 0x"$1 " 0x"$3 " " $5;
> +}
> +
> +# (LLD) Convert a symbol record from lld format to ld format.
> +#
> +# We only care about these while processing a section for which no anchor has
> +# been determined yet.
> +#
> +# lld: ffffffff82a859a4          2a859a4        0     1                 btf_ksym_iter_id
> +#  ->
> +# ld:                  0xffffffff82a859a4                btf_ksym_iter_id
> +#
> +ARGIND == 2 && map_is_lld && sect && !anchor && NF == 5 && $5 ~ /^[_A-Za-z][_A-Za-z0-9]*$/ {
> +	$0 = "  0x"$1 " " $5;
> +}
> +
> +# (LLD) We do not need any other ldd linker map records.
> +#
> +ARGIND == 2 && map_is_lld && /^[0-9a-f]{16} / {
> +	next;
> +}
> +
> +# (LD) Section records with just the section name at the start of the line
> +#      need to have the next line pulled in to determine whether it is a
> +#      loadable section.  If it is, the next line will contains a hex value
> +#      as first and second items.
> +#
> +ARGIND == 2 && !map_is_lld && NF == 1 && /^[^ ]/ {
> +	s = $0;
> +	getline;
> +	if ($1 !~ /^0x/ || $2 !~ /^0x/)
> +		next;
> +
> +	$0 = s " " $0;
> +}
> +
> +# (LD) Object records with just the section name denote records with a long
> +#      section name for which the remainder of the record can be found on the
> +#      next line.
> +#
> +# (This is also needed for vmlinux.o.map, when used.)
> +#
> +ARGIND >= 2 && !map_is_lld && NF == 1 && /^ [^ \*]/ {
> +	s = $0;
> +	getline;
> +	$0 = s " " $0;
> +}
> +
> +# Beginning a new section - done with the previous one (if any).
> +#
> +ARGIND == 2 && /^[^ ]/ {
> +	sect = 0;
> +}
> +
> +# Process a loadable section (we only care about .-sections).
> +#
> +# Record the section name and its base address.
> +# We also record the raw (non-stripped) address of the section because it can
> +# be used to identify an anchor record.
> +#
> +# Note:
> +# Since some AWK implementations cannot handle large integers, we strip off the
> +# first 4 hex digits from the address.  This is safe because the kernel space
> +# is not large enough for addresses to extend into those digits.  The portion
> +# to strip off is stored in addr_prefix as a regexp, so further clauses can
> +# perform a simple substitution to do the address stripping.
> +#
> +ARGIND == 2 && /^\./ {
> +	# Explicitly ignore a few sections that are not relevant here.
> +	if ($1 ~ /^\.orc_/ || $1 ~ /_sites$/ || $1 ~ /\.percpu/)
> +		next;
> +
> +	# Sections with a 0-address can be ignored as well.
> +	if ($2 ~ /^0x0+$/)
> +		next;
> +
> +	raw_addr = $2;
> +	addr_prefix = "^" substr($2, 1, 6);
> +	base = $2;
> +	sub(addr_prefix, "0x", base);
> +	base = strtonum(base);
> +	sect = $1;
> +	anchor = 0;
> +	sect_base[sect] = base;
> +	sect_size[sect] = strtonum($3);
> +
> +	if (dbg)
> +		printf "[%s] BASE   %016x\n", sect, base >"/dev/stderr";
> +
> +	next;
> +}
> +
> +# If we are not in a section we care about, we ignore the record.
> +#
> +ARGIND == 2 && !sect {
> +	next;
> +}
> +
> +# Record the first anchor symbol for the current section.
> +#
> +# An anchor record for the section bears the same raw address as the section
> +# record.
> +#
> +ARGIND == 2 && !anchor && NF == 4 && raw_addr == $1 && $3 == "=" && $4 == "." {
> +	anchor = sprintf("%s %08x-%08x = %s", sect, 0, 0, $2);
> +	sect_anchor[sect] = anchor;
> +
> +	if (dbg)
> +		printf "[%s] ANCHOR %016x = %s (.)\n", sect, 0, $2 >"/dev/stderr";
> +
> +	next;
> +}
> +
> +# If no anchor record was found for the current section, use the first symbol
> +# in the section as anchor.
> +#
> +ARGIND == 2 && !anchor && NF == 2 && $1 ~ /^0x/ && $2 !~ /^0x/ {
> +	addr = $1;
> +	sub(addr_prefix, "0x", addr);
> +	addr = strtonum(addr) - base;
> +	anchor = sprintf("%s %08x-%08x = %s", sect, addr, addr, $2);
> +	sect_anchor[sect] = anchor;
> +
> +	if (dbg)
> +		printf "[%s] ANCHOR %016x = %s\n", sect, addr, $2 >"/dev/stderr";
> +
> +	next;
> +}
> +
> +# The first occurrence of a section name in an object record establishes the
> +# addend (often 0) for that section.  This information is needed to handle
> +# sections that get combined in the final linking of vmlinux (e.g. .head.text
> +# getting included at the start of .text).
> +#
> +# If the section does not have a base yet, use the base of the encapsulating
> +# section.
> +#
> +ARGIND == 2 && sect && NF == 4 && /^ [^ \*]/ && !($1 in sect_addend) {
> +	if (!($1 in sect_base)) {
> +		sect_base[$1] = base;
> +
> +		if (dbg)
> +			printf "[%s] BASE   %016x\n", $1, base >"/dev/stderr";
> +	}
> +
> +	addr = $2;
> +	sub(addr_prefix, "0x", addr);
> +	addr = strtonum(addr);
> +	sect_addend[$1] = addr - sect_base[$1];
> +	sect_in[$1] = sect;
> +
> +	if (dbg)
> +		printf "[%s] ADDEND %016x - %016x = %016x\n",  $1, addr, base, sect_addend[$1] >"/dev/stderr";
> +
> +	# If the object is vmlinux.o then we will need vmlinux.o.map to get the
> +	# actual offsets of objects.
> +	if ($4 == "vmlinux.o")
> +		need_o_map = 1;
> +}
> +
> +# (3) Collect offset ranges (relative to the section base address) for built-in
> +# modules.
> +#
> +# If the final link was done using the actual objects, vmlinux.map contains all
> +# the information we need (see section (3a)).
> +# If linking was done using vmlinux.a as intermediary, we will need to process
> +# vmlinux.o.map (see section (3b)).
> +
> +# (3a) Determine offset range info using vmlinux.map.
> +#
> +# Since we are already processing vmlinux.map, the top level section that is
> +# being processed is already known.  If we do not have a base address for it,
> +# we do not need to process records for it.
> +#
> +# Given the object name, we determine the module(s) (if any) that the current
> +# object is associated with.
> +#
> +# If we were already processing objects for a (list of) module(s):
> +#  - If the current object belongs to the same module(s), update the range data
> +#    to include the current object.
> +#  - Otherwise, ensure that the end offset of the range is valid.
> +#
> +# If the current object does not belong to a built-in module, ignore it.
> +#
> +# If it does, we add a new built-in module offset range record.
> +#
> +ARGIND == 2 && !need_o_map && /^ [^ ]/ && NF == 4 && $3 != "0x0" {
> +	if (!(sect in sect_base))
> +		next;
> +
> +	# Turn the address into an offset from the section base.
> +	soff = $2;
> +	sub(addr_prefix, "0x", soff);
> +	soff = strtonum(soff) - sect_base[sect];
> +	eoff = soff + strtonum($3);
> +
> +	# Determine which (if any) built-in modules the object belongs to.
> +	mod = get_module_info($4);
> +
> +	# If we are processing a built-in module:
> +	#   - If the current object is within the same module, we update its
> +	#     entry by extending the range and move on
> +	#   - Otherwise:
> +	#       + If we are still processing within the same main section, we
> +	#         validate the end offset against the start offset of the
> +	#         current object (e.g. .rodata.str1.[18] objects are often
> +	#         listed with an incorrect size in the linker map)
> +	#       + Otherwise, we validate the end offset against the section
> +	#         size
> +	if (mod_name) {
> +		if (mod == mod_name) {
> +			mod_eoff = eoff;
> +			update_entry(mod_sect, mod_name, mod_soff, eoff);
> +
> +			next;
> +		} else if (sect == sect_in[mod_sect]) {
> +			if (mod_eoff > soff)
> +				update_entry(mod_sect, mod_name, mod_soff, soff);
> +		} else {
> +			v = sect_size[sect_in[mod_sect]];
> +			if (mod_eoff > v)
> +				update_entry(mod_sect, mod_name, mod_soff, v);
> +		}
> +	}
> +
> +	mod_name = mod;
> +
> +	# If we encountered an object that is not part of a built-in module, we
> +	# do not need to record any data.
> +	if (!mod)
> +		next;
> +
> +	# At this point, we encountered the start of a new built-in module.
> +	mod_name = mod;
> +	mod_soff = soff;
> +	mod_eoff = eoff;
> +	mod_sect = $1;
> +	update_entry($1, mod, soff, mod_eoff);
> +
> +	next;
> +}
> +
> +# If we do not need to parse the vmlinux.o.map file, we are done.
> +#
> +ARGIND == 3 && !need_o_map {
> +	if (dbg)
> +		printf "Note: %s is not needed.\n", FILENAME >"/dev/stderr";
> +	exit;
> +}
> +
> +# (3) Collect offset ranges (relative to the section base address) for built-in
> +# modules.
> +#
> +
> +# (LLD) Convert an object record from lld format to ld format.
> +#
> +ARGIND == 3 && map_is_lld && NF == 5 && $5 ~ /:\(/ {
> +	gsub(/\)/, "");
> +	sub(/:\(/, " ");
> +
> +	sect = $6;
> +	if (!(sect in sect_addend))
> +		next;
> +
> +	sub(/ vmlinux\.a\(/, " ");
> +	$0 = " "sect " 0x"$1 " 0x"$3 " " $5;
> +}
> +
> +# (3b) Determine offset range info using vmlinux.o.map.
> +#
> +# If we do not know an addend for the object's section, we are interested in
> +# anything within that section.
> +#
> +# Determine the top-level section that the object's section was included in
> +# during the final link.  This is the section name offset range data will be
> +# associated with for this object.
> +#
> +# The remainder of the processing of the current object record follows the
> +# procedure outlined in (3a).
> +#
> +ARGIND == 3 && /^ [^ ]/ && NF == 4 && $3 != "0x0" {
> +	osect = $1;
> +	if (!(osect in sect_addend))
> +		next;
> +
> +	# We need to work with the main section.
> +	sect = sect_in[osect];
> +
> +	# Turn the address into an offset from the section base.
> +	soff = $2;
> +	sub(addr_prefix, "0x", soff);
> +	soff = strtonum(soff) + sect_addend[osect];
> +	eoff = soff + strtonum($3);
> +
> +	# Determine which (if any) built-in modules the object belongs to.
> +	mod = get_module_info($4);
> +
> +	# If we are processing a built-in module:
> +	#   - If the current object is within the same module, we update its
> +	#     entry by extending the range and move on
> +	#   - Otherwise:
> +	#       + If we are still processing within the same main section, we
> +	#         validate the end offset against the start offset of the
> +	#         current object (e.g. .rodata.str1.[18] objects are often
> +	#         listed with an incorrect size in the linker map)
> +	#       + Otherwise, we validate the end offset against the section
> +	#         size
> +	if (mod_name) {
> +		if (mod == mod_name) {
> +			mod_eoff = eoff;
> +			update_entry(mod_sect, mod_name, mod_soff, eoff);
> +
> +			next;
> +		} else if (sect == sect_in[mod_sect]) {
> +			if (mod_eoff > soff)
> +				update_entry(mod_sect, mod_name, mod_soff, soff);
> +		} else {
> +			v = sect_size[sect_in[mod_sect]];
> +			if (mod_eoff > v)
> +				update_entry(mod_sect, mod_name, mod_soff, v);
> +		}
> +	}
> +
> +	mod_name = mod;
> +
> +	# If we encountered an object that is not part of a built-in module, we
> +	# do not need to record any data.
> +	if (!mod)
> +		next;
> +
> +	# At this point, we encountered the start of a new built-in module.
> +	mod_name = mod;
> +	mod_soff = soff;
> +	mod_eoff = eoff;
> +	mod_sect = osect;
> +	update_entry(osect, mod, soff, mod_eoff);
> +
> +	next;
> +}
> +
> +# (4) Generate the output.
> +#
> +# Anchor records are added for each section that contains offset range data
> +# records.  They are added at an adjusted section base address (base << 1) to
> +# ensure they come first in the second records (see update_entry() above for
> +# more information).
> +#
> +# All entries are sorted by (adjusted) address to ensure that the output can be
> +# parsed in strict ascending address order.
> +#
> +END {
> +	for (sect in count) {
> +		if (sect in sect_anchor) {
> +			idx = sprintf("%016x", sect_base[sect] * 2);
> +			entries[idx] = sect_anchor[sect];
> +		}
> +	}
> +
> +	n = asorti(entries, indices);
> +	for (i = 1; i <= n; i++)
> +		print entries[indices[i]];
> +}
> -- 
> 2.45.2
> 




[Index of Archives]     [Linux USB Devel]     [Video for Linux]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]     [Big List of Linux Books]

  Powered by Linux