Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514#!/usr/bin/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@oracle.com>## 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) { # There are a few sections with constant data (without symbols) that # can get resized during linking, so it is best to ignore them. if ($1 ~ /^\.rodata\.(cst|str)[0-9]/) next;
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]];}