[PATCH v4 09/14] objtool/klp: Convert local label references

From: George Guo <redacted>

Some toolchains reference an object through a local assembler label (.L*)
rather than a section symbol plus offset.  The assembler keeps the label
because a "section + constant offset" reference would go stale under
linker relaxation, while a symbol reference can be recomputed afterwards.
Such labels are assembler-local, absent from kallsyms, and are never
cloned into the livepatch object.

Two toolchains hit this:

  - GCC/GAS on LoongArch references special section entries (__ex_table,
    __bug_table, __jump_table, .altinstructions) through local text
    labels instead of a section symbol.

  - Clang emits a switch jump table through a local label (.LJTI*) in a
    SHF_MERGE|SHF_STRINGS .rodata section, where the table shares the
    section with the livepatch's klp_func name strings.

convert_reloc_secsym_to_sym() only handled the section symbol form and
returned early for a label reference, so the label was never converted
and the reference resolved incorrectly, with no error at build or load
time:

  - GCC: should_keep_special_sym() cannot correlate the entry with an
    included function and silently drops it, so the livepatch module is
    missing the patched function's __ex_table / __bug_table /
    __jump_table entries.

  - Clang: the jump table is not cloned, and its base label resolves into
    the name strings that occupy the same offset; the switch's indirect
    jump then lands on a wild address and the patched function oopses at
    runtime.

Redirect a local label reference off the label, mirroring the section
symbol case:

  - In a text section, to the containing function symbol.  A label with
    no containing function symbol (e.g. hand-written asm in a plain .text
    section) can't be correlated; skip it rather than failing, since such
    entries belong to unchanged code and are dropped anyway.

  - In a non-text section (e.g. the .rodata jump table), to the section
    symbol plus the full offset.

Reported-by: Joe Lawrence <joe.lawrence@redhat.com>
Suggested-by: Joe Lawrence <joe.lawrence@redhat.com>
Co-developed-by: Kexin Liu <redacted>
Signed-off-by: Kexin Liu <redacted>
Signed-off-by: George Guo <redacted>
---
 tools/objtool/klp-diff.c | 49 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/tools/objtool/klp-diff.c b/tools/objtool/klp-diff.c
index b9624bd9439b..3e573b73fe6b 100644
--- a/tools/objtool/klp-diff.c
+++ b/tools/objtool/klp-diff.c

@@ -1423,8 +1423,55 @@ static int convert_reloc_secsym_to_sym(struct elf *elf, struct reloc *reloc)
 	if (!strcmp(reloc->sec->name, ".rela__patchable_function_entries"))
 		return convert_pfe_reloc(elf, reloc);
 
-	if (!is_sec_sym(sym))
+	if (!is_sec_sym(sym)) {
+		/*
+		 * Most toolchains reference special-section entries via the
+		 * section symbol plus an offset.  GCC/GAS on LoongArch instead
+		 * references a local text label (.L*): LoongArch linker
+		 * relaxation is the reason GAS keeps the label rather than
+		 * reducing it to a section symbol reference.  Such a label is
+		 * never cloned into the livepatch object, so the entry would be
+		 * silently dropped.  Redirect the relocation to the containing
+		 * function, mirroring the section-symbol case below.
+		 */
+		if (is_local_label(sym)) {
+			unsigned long offset = sym->offset + reloc_addend(reloc);
+
+			if (is_text_sec(sec)) {
+				sym = find_symbol_containing_inclusive(sec, offset);
+				if (!sym) {
+					/*
+					 * A local label with no containing function
+					 * symbol (e.g. hand-written asm in a plain .text
+					 * section).  It can't be correlated to a function,
+					 * so skip it rather than failing the build; such
+					 * entries belong to unchanged code and are dropped
+					 * anyway.
+					 */
+					return 1;
+				}
+
+				reloc->sym = sym;
+				set_reloc_sym(elf, reloc, sym->idx);
+				set_reloc_addend(elf, reloc, offset - sym->offset);
+			} else {
+				/*
+				 * A local label in a non-text section, e.g. Clang's
+				 * .LJTI* switch jump table in .rodata.  It isn't
+				 * cloned into the livepatch either, so redirect the
+				 * reloc to the section symbol plus the full offset,
+				 * mirroring the section-symbol case below.
+				 */
+				if (!sec->sym && !elf_create_section_symbol(elf, sec))
+					return -1;
+				reloc->sym = sec->sym;
+				set_reloc_sym(elf, reloc, sec->sym->idx);
+				set_reloc_addend(elf, reloc, offset);
+			}
+		}
+
 		return 0;
+	}
 
 	sym = find_symbol_containing_inclusive(sec, arch_adjusted_addend(reloc));
 	if (!sym) {

-- 
2.53.0