[PATCH v5 03/11] modpost: cache section relocation mismatch state

["Lorenzo Stoakes (ARM)" <ljs@kernel.org>]

For every relocation modpost invokes check_section_mismatch() to determine
whether there is any kind of mismatch between the source and destination,
and if so which classification applies.

Each time it does this it invokes section_mismatch() which iterates
through the sectioncheck[] array every time it's called.

When walked a relocation section the source is fixed and there aren't many
targets, so the same names are looked up over and over again.

Therefore cache not only mismatch categorisation but also whether a
mismatch even exists for a given section and look up the sections in the
cache.

Special indices (undefined, absolute, common) take the uncached path as
before.

This results in very significant speed ups for allmodconfig incremental
builds.

modpost is on the serial tail of every build that links vmlinux.

Whole build, 128-thread Threadripper 9980X, best of N runs:

                                         before   after     delta
                                         -------------------------------
  x86 defconfig, touch mm/vma.c, gcc        8.5s     8.3s    -0.14s (-2%)
  x86 defconfig, touch mm/vma.c, clang      7.7s     7.6s    -0.13s (-2%)
  x86 allmodconfig, touch mm/vma.c, gcc    33.9s    29.4s     -4.5s (-13%)
  x86 allmodconfig, touch mm/vma.c, clang  31.9s    27.9s     -4.0s (-13%)

Signed-off-by: Lorenzo Stoakes (ARM) <ljs@kernel.org>
---
 scripts/mod/modpost.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++--
 scripts/mod/modpost.h |  8 +++++++
 2 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
index 75374c64b8cc..83caf29b4bf2 100644
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -1155,12 +1155,62 @@ static void check_export_symbol(struct module *mod, struct elf_info *elf,
 			 name);
 }
 
+static void init_mismatch_cache(struct elf_info *elf)
+{
+	elf->mismatch_cache = xcalloc(elf->num_sections,
+				      sizeof(*elf->mismatch_cache));
+}
+
+static void reset_mismatch_cache(struct elf_info *elf)
+{
+	memset(elf->mismatch_cache, 0,
+	       elf->num_sections * sizeof(*elf->mismatch_cache));
+}
+
+static void free_mismatch_cache(struct elf_info *elf)
+{
+	free(elf->mismatch_cache);
+	elf->mismatch_cache = NULL;
+}
+
+static const struct sectioncheck
+*cache_mismatch(const struct elf_info *elf, unsigned int to_secndx,
+		const struct sectioncheck *mismatch)
+{
+	if (!mismatch) {
+		elf->mismatch_cache[to_secndx] = -1;
+		return NULL;
+	}
+
+	elf->mismatch_cache[to_secndx] = (mismatch - sectioncheck) + 1;
+	return mismatch;
+}
+
+static const struct sectioncheck *get_section_mismatch(const struct elf_info *elf,
+		const char *fromsec, unsigned int to_secndx)
+{
+	int cached;
+
+	if (to_secndx >= elf->num_sections)
+		return section_mismatch(fromsec, sec_name(elf, to_secndx));
+
+	cached = elf->mismatch_cache[to_secndx];
+	if (cached < 0)
+		return NULL;
+	if (cached > 0)
+		return &sectioncheck[cached - 1];
+
+	return cache_mismatch(elf, to_secndx,
+			      section_mismatch(fromsec, sec_name(elf, to_secndx)));
+}
+
 static void check_section_mismatch(struct module *mod, struct elf_info *elf,
 				   Elf_Sym *sym,
 				   unsigned int fsecndx, const char *fromsec,
 				   Elf_Addr faddr, Elf_Addr taddr)
 {
-	const char *tosec = sec_name(elf, get_secindex(elf, sym));
+	unsigned int to_secndx = get_secindex(elf, sym);
+	const char *tosec = sec_name(elf, to_secndx);
 	const struct sectioncheck *mismatch;
 
 	if (module_enabled && elf->export_symbol_secndx == fsecndx) {
@@ -1168,7 +1218,7 @@ static void check_section_mismatch(struct module *mod, struct elf_info *elf,
 		return;
 	}
 
-	mismatch = section_mismatch(fromsec, tosec);
+	mismatch = get_section_mismatch(elf, fromsec, to_secndx);
 	if (!mismatch)
 		return;
 
@@ -1445,6 +1495,8 @@ static void check_sec_ref(struct module *mod, struct elf_info *elf)
 {
 	int i;
 
+	init_mismatch_cache(elf);
+
 	/* Walk through all sections */
 	for (i = 0; i < elf->num_sections; i++) {
 		Elf_Shdr *sechdr = &elf->sechdrs[i];
@@ -1461,6 +1513,9 @@ static void check_sec_ref(struct module *mod, struct elf_info *elf)
 			if (match(secname, section_white_list))
 				continue;
 
+			/* Reset cache per-section. */
+			reset_mismatch_cache(elf);
+
 			start = sym_get_data_by_offset(elf, i, 0);
 			stop = start + sechdr->sh_size;
 
@@ -1472,6 +1527,8 @@ static void check_sec_ref(struct module *mod, struct elf_info *elf)
 					    start, stop);
 		}
 	}
+
+	free_mismatch_cache(elf);
 }
 
 static char *remove_dot(char *s)
diff --git a/scripts/mod/modpost.h b/scripts/mod/modpost.h
index 666beca685e4..7ba64fd894ef 100644
--- a/scripts/mod/modpost.h
+++ b/scripts/mod/modpost.h
@@ -160,6 +160,14 @@ struct elf_info {
 	Elf32_Word   *symtab_shndx_stop;
 
 	struct symsearch *symsearch;
+
+	/*
+	 * Section mismatch cache, indexed by destination section:
+	 *   0 - uncached.
+	 *  -1 - no mismatch.
+	 *  >0 - mismatch index + 1.
+	 */
+	int *mismatch_cache;
 };
 
 /* Accessor for sym->st_shndx, hides ugliness of "64k sections" */

-- 
2.56.0