diff mbox series

[4/8] kbuild: simplify dependency generation for CONFIG_TRIM_UNUSED_KSYMS

Message ID 1542270435-11181-5-git-send-email-yamada.masahiro@socionext.com
State Superseded
Headers show
Series kbuild: clean-up modversion, TRIM_UNUSED_KSYMS, if_changed_rule, etc. | expand

Commit Message

Masahiro Yamada Nov. 15, 2018, 8:27 a.m. UTC
My main motivation of this commit is to clean up scripts/Kbuild.include
and scripts/Makefile.build.

Currently, CONFIG_TRIM_UNUSED_KSYMS works with a tricky gimmick;
possibly exported symbols are detected by letting $(CPP) replace
EXPORT_SYMBOL* with a special string '=== __KSYM_*===', which is
post-processed by sed, and passed to fixdep. The extra preprocessing
is costly, and hacking cmd_and_fixdep is ugly.

I came up with a new way to find exported symbols; insert a dummy
symbol __ksym_marker_* to each potentially exported symbol. Those
dummy symbols are picked up by $(NM), post-processed by sed, then
appended to .*.cmd files. I collected the post-process part to a
new shell script scripts/gen_ksymdeps.sh for readability. The dummy
symbols are put into the .discard.* section so that the linker
script rips them off the final vmlinux or modules.

A nice side-effect is building with CONFIG_TRIM_UNUSED_KSYMS will
be much faster.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>

---

 include/asm-generic/export.h | 13 ++++++++-----
 include/linux/export.h       | 18 +++++++++---------
 scripts/Kbuild.include       | 29 -----------------------------
 scripts/Makefile.build       | 10 ++++++++++
 scripts/basic/fixdep.c       | 31 ++++---------------------------
 scripts/gen_ksymdeps.sh      | 25 +++++++++++++++++++++++++
 6 files changed, 56 insertions(+), 70 deletions(-)
 create mode 100755 scripts/gen_ksymdeps.sh

-- 
2.7.4

Comments

Nicolas Pitre Nov. 16, 2018, 5:13 a.m. UTC | #1
On Thu, 15 Nov 2018, Masahiro Yamada wrote:

> My main motivation of this commit is to clean up scripts/Kbuild.include

> and scripts/Makefile.build.

> 

> Currently, CONFIG_TRIM_UNUSED_KSYMS works with a tricky gimmick;

> possibly exported symbols are detected by letting $(CPP) replace

> EXPORT_SYMBOL* with a special string '=== __KSYM_*===', which is

> post-processed by sed, and passed to fixdep. The extra preprocessing

> is costly, and hacking cmd_and_fixdep is ugly.

> 

> I came up with a new way to find exported symbols; insert a dummy

> symbol __ksym_marker_* to each potentially exported symbol. Those

> dummy symbols are picked up by $(NM), post-processed by sed, then

> appended to .*.cmd files. I collected the post-process part to a

> new shell script scripts/gen_ksymdeps.sh for readability. The dummy

> symbols are put into the .discard.* section so that the linker

> script rips them off the final vmlinux or modules.


Brilliant!  I really like it.

Minor comments below.

> diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h

> index 4d73e6e..294d6ae 100644

> --- a/include/asm-generic/export.h

> +++ b/include/asm-generic/export.h

> @@ -59,16 +59,19 @@ __kcrctab_\name:

>  .endm

>  #undef __put

>  

> -#if defined(__KSYM_DEPS__)

> -

> -#define __EXPORT_SYMBOL(sym, val, sec)	=== __KSYM_##sym ===

> -

> -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> +#if defined(CONFIG_TRIM_UNUSED_KSYMS)

>  

>  #include <linux/kconfig.h>

>  #include <generated/autoksyms.h>

>  

> +.macro __ksym_marker sym

> +	.section ".discard.ksym","a"

> +__ksym_marker_\sym:

> +	 .previous


Does this work as intended? I have vague memories about having problems 
with sections being discarded when they don't allocate any space.

> +.endm

> +

>  #define __EXPORT_SYMBOL(sym, val, sec)				\

> +	__ksym_marker sym;					\

>  	__cond_export_sym(sym, val, sec, __is_defined(__KSYM_##sym))

>  #define __cond_export_sym(sym, val, sec, conf)			\

>  	___cond_export_sym(sym, val, sec, conf)

> diff --git a/include/linux/export.h b/include/linux/export.h

> index ce764a5..0413a3d 100644

> --- a/include/linux/export.h

> +++ b/include/linux/export.h

> @@ -92,22 +92,22 @@ struct kernel_symbol {

>   */

>  #define __EXPORT_SYMBOL(sym, sec)

>  

> -#elif defined(__KSYM_DEPS__)

> +#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> +

> +#include <generated/autoksyms.h>

>  

>  /*

>   * For fine grained build dependencies, we want to tell the build system

>   * about each possible exported symbol even if they're not actually exported.

> - * We use a string pattern that is unlikely to be valid code that the build

> - * system filters out from the preprocessor output (see ksym_dep_filter

> - * in scripts/Kbuild.include).

> + * We use a symbol pattern __ksym_marker_<symbol> that the build system filters

> + * from the $(NM) output (see scripts/gen_ksymdep.sh). These symbols are

> + * discarded in the final link stage.

>   */

> -#define __EXPORT_SYMBOL(sym, sec)	=== __KSYM_##sym ===

> -

> -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> -

> -#include <generated/autoksyms.h>

> +#define __ksym_marker(sym)	\

> +	static int __ksym_marker_##sym[0] __section(".discard.ksym") __used


Even if this is discarded during the final link, maybe this could save 
a tiny amount of disk space by using a char instead?

> diff --git a/scripts/Makefile.build b/scripts/Makefile.build

> index 7f3ca6e..e5ba9b1 100644

> --- a/scripts/Makefile.build

> +++ b/scripts/Makefile.build

> @@ -254,9 +254,18 @@ objtool_dep = $(objtool_obj)					\

>  	      $(wildcard include/config/orc/unwinder.h		\

>  			 include/config/stack/validation.h)

>  

> +ifdef CONFIG_TRIM_UNUSED_KSYMS

> +cmd_gen_ksymdeps = \

> +	$(CONFIG_SHELL) $(srctree)/scripts/gen_ksymdeps.sh $@ > $(dot-target).tmp; \

> +	cat $(dot-target).tmp >> $(dot-target).cmd; \

> +	rm -f $(dot-target).tmp;


Why don't you append to $(dot-target).cmd directly?


Nicolas
Masahiro Yamada Nov. 16, 2018, 7:13 a.m. UTC | #2
On Fri, Nov 16, 2018 at 2:13 PM Nicolas Pitre <nicolas.pitre@linaro.org> wrote:
>

> On Thu, 15 Nov 2018, Masahiro Yamada wrote:

>

> > My main motivation of this commit is to clean up scripts/Kbuild.include

> > and scripts/Makefile.build.

> >

> > Currently, CONFIG_TRIM_UNUSED_KSYMS works with a tricky gimmick;

> > possibly exported symbols are detected by letting $(CPP) replace

> > EXPORT_SYMBOL* with a special string '=== __KSYM_*===', which is

> > post-processed by sed, and passed to fixdep. The extra preprocessing

> > is costly, and hacking cmd_and_fixdep is ugly.

> >

> > I came up with a new way to find exported symbols; insert a dummy

> > symbol __ksym_marker_* to each potentially exported symbol. Those

> > dummy symbols are picked up by $(NM), post-processed by sed, then

> > appended to .*.cmd files. I collected the post-process part to a

> > new shell script scripts/gen_ksymdeps.sh for readability. The dummy

> > symbols are put into the .discard.* section so that the linker

> > script rips them off the final vmlinux or modules.

>

> Brilliant!  I really like it.

>

> Minor comments below.

>

> > diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h

> > index 4d73e6e..294d6ae 100644

> > --- a/include/asm-generic/export.h

> > +++ b/include/asm-generic/export.h

> > @@ -59,16 +59,19 @@ __kcrctab_\name:

> >  .endm

> >  #undef __put

> >

> > -#if defined(__KSYM_DEPS__)

> > -

> > -#define __EXPORT_SYMBOL(sym, val, sec)       === __KSYM_##sym ===

> > -

> > -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > +#if defined(CONFIG_TRIM_UNUSED_KSYMS)

> >

> >  #include <linux/kconfig.h>

> >  #include <generated/autoksyms.h>

> >

> > +.macro __ksym_marker sym

> > +     .section ".discard.ksym","a"

> > +__ksym_marker_\sym:

> > +      .previous

>

> Does this work as intended? I have vague memories about having problems

> with sections being discarded when they don't allocate any space.


What I can tell is, this patch produces the same size kernel
(after dropping debug info by 'strip' command).


> > +.endm

> > +

> >  #define __EXPORT_SYMBOL(sym, val, sec)                               \

> > +     __ksym_marker sym;                                      \

> >       __cond_export_sym(sym, val, sec, __is_defined(__KSYM_##sym))

> >  #define __cond_export_sym(sym, val, sec, conf)                       \

> >       ___cond_export_sym(sym, val, sec, conf)

> > diff --git a/include/linux/export.h b/include/linux/export.h

> > index ce764a5..0413a3d 100644

> > --- a/include/linux/export.h

> > +++ b/include/linux/export.h

> > @@ -92,22 +92,22 @@ struct kernel_symbol {

> >   */

> >  #define __EXPORT_SYMBOL(sym, sec)

> >

> > -#elif defined(__KSYM_DEPS__)

> > +#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > +

> > +#include <generated/autoksyms.h>

> >

> >  /*

> >   * For fine grained build dependencies, we want to tell the build system

> >   * about each possible exported symbol even if they're not actually exported.

> > - * We use a string pattern that is unlikely to be valid code that the build

> > - * system filters out from the preprocessor output (see ksym_dep_filter

> > - * in scripts/Kbuild.include).

> > + * We use a symbol pattern __ksym_marker_<symbol> that the build system filters

> > + * from the $(NM) output (see scripts/gen_ksymdep.sh). These symbols are

> > + * discarded in the final link stage.

> >   */

> > -#define __EXPORT_SYMBOL(sym, sec)    === __KSYM_##sym ===

> > -

> > -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > -

> > -#include <generated/autoksyms.h>

> > +#define __ksym_marker(sym)   \

> > +     static int __ksym_marker_##sym[0] __section(".discard.ksym") __used

>

> Even if this is discarded during the final link, maybe this could save

> a tiny amount of disk space by using a char instead?



I am afraid you missed '[0]' after the symbol name.
This is actually zero-length array.

No memory allocated for this dummy section.

As far as I tested, this is working.





> > diff --git a/scripts/Makefile.build b/scripts/Makefile.build

> > index 7f3ca6e..e5ba9b1 100644

> > --- a/scripts/Makefile.build

> > +++ b/scripts/Makefile.build

> > @@ -254,9 +254,18 @@ objtool_dep = $(objtool_obj)                                     \

> >             $(wildcard include/config/orc/unwinder.h          \

> >                        include/config/stack/validation.h)

> >

> > +ifdef CONFIG_TRIM_UNUSED_KSYMS

> > +cmd_gen_ksymdeps = \

> > +     $(CONFIG_SHELL) $(srctree)/scripts/gen_ksymdeps.sh $@ > $(dot-target).tmp; \

> > +     cat $(dot-target).tmp >> $(dot-target).cmd; \

> > +     rm -f $(dot-target).tmp;

>

> Why don't you append to $(dot-target).cmd directly?



If scripts/gen_ksymdeps.sh fails for some reasons,
it will error out immediately thanks to 'set -e' flag.

Appending incomplete portion might end up with a corrupted .*.cmd file.

Probably, that would not happen, but I just wanted to ensure it.




>

> Nicolas




--
Best Regards
Masahiro Yamada
Nicolas Pitre Nov. 16, 2018, 5:49 p.m. UTC | #3
On Fri, 16 Nov 2018, Masahiro Yamada wrote:

> On Fri, Nov 16, 2018 at 2:13 PM Nicolas Pitre <nicolas.pitre@linaro.org> wrote:

> >

> > On Thu, 15 Nov 2018, Masahiro Yamada wrote:

> >

> > > My main motivation of this commit is to clean up scripts/Kbuild.include

> > > and scripts/Makefile.build.

> > >

> > > Currently, CONFIG_TRIM_UNUSED_KSYMS works with a tricky gimmick;

> > > possibly exported symbols are detected by letting $(CPP) replace

> > > EXPORT_SYMBOL* with a special string '=== __KSYM_*===', which is

> > > post-processed by sed, and passed to fixdep. The extra preprocessing

> > > is costly, and hacking cmd_and_fixdep is ugly.

> > >

> > > I came up with a new way to find exported symbols; insert a dummy

> > > symbol __ksym_marker_* to each potentially exported symbol. Those

> > > dummy symbols are picked up by $(NM), post-processed by sed, then

> > > appended to .*.cmd files. I collected the post-process part to a

> > > new shell script scripts/gen_ksymdeps.sh for readability. The dummy

> > > symbols are put into the .discard.* section so that the linker

> > > script rips them off the final vmlinux or modules.

> >

> > Brilliant!  I really like it.

> >

> > Minor comments below.

> >

> > > diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h

> > > index 4d73e6e..294d6ae 100644

> > > --- a/include/asm-generic/export.h

> > > +++ b/include/asm-generic/export.h

> > > @@ -59,16 +59,19 @@ __kcrctab_\name:

> > >  .endm

> > >  #undef __put

> > >

> > > -#if defined(__KSYM_DEPS__)

> > > -

> > > -#define __EXPORT_SYMBOL(sym, val, sec)       === __KSYM_##sym ===

> > > -

> > > -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > > +#if defined(CONFIG_TRIM_UNUSED_KSYMS)

> > >

> > >  #include <linux/kconfig.h>

> > >  #include <generated/autoksyms.h>

> > >

> > > +.macro __ksym_marker sym

> > > +     .section ".discard.ksym","a"

> > > +__ksym_marker_\sym:

> > > +      .previous

> >

> > Does this work as intended? I have vague memories about having problems

> > with sections being discarded when they don't allocate any space.

> 

> What I can tell is, this patch produces the same size kernel

> (after dropping debug info by 'strip' command).

> 

> 

> > > +.endm

> > > +

> > >  #define __EXPORT_SYMBOL(sym, val, sec)                               \

> > > +     __ksym_marker sym;                                      \

> > >       __cond_export_sym(sym, val, sec, __is_defined(__KSYM_##sym))

> > >  #define __cond_export_sym(sym, val, sec, conf)                       \

> > >       ___cond_export_sym(sym, val, sec, conf)

> > > diff --git a/include/linux/export.h b/include/linux/export.h

> > > index ce764a5..0413a3d 100644

> > > --- a/include/linux/export.h

> > > +++ b/include/linux/export.h

> > > @@ -92,22 +92,22 @@ struct kernel_symbol {

> > >   */

> > >  #define __EXPORT_SYMBOL(sym, sec)

> > >

> > > -#elif defined(__KSYM_DEPS__)

> > > +#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > > +

> > > +#include <generated/autoksyms.h>

> > >

> > >  /*

> > >   * For fine grained build dependencies, we want to tell the build system

> > >   * about each possible exported symbol even if they're not actually exported.

> > > - * We use a string pattern that is unlikely to be valid code that the build

> > > - * system filters out from the preprocessor output (see ksym_dep_filter

> > > - * in scripts/Kbuild.include).

> > > + * We use a symbol pattern __ksym_marker_<symbol> that the build system filters

> > > + * from the $(NM) output (see scripts/gen_ksymdep.sh). These symbols are

> > > + * discarded in the final link stage.

> > >   */

> > > -#define __EXPORT_SYMBOL(sym, sec)    === __KSYM_##sym ===

> > > -

> > > -#elif defined(CONFIG_TRIM_UNUSED_KSYMS)

> > > -

> > > -#include <generated/autoksyms.h>

> > > +#define __ksym_marker(sym)   \

> > > +     static int __ksym_marker_##sym[0] __section(".discard.ksym") __used

> >

> > Even if this is discarded during the final link, maybe this could save

> > a tiny amount of disk space by using a char instead?

> 

> 

> I am afraid you missed '[0]' after the symbol name.

> This is actually zero-length array.


Ah, indeed.

> No memory allocated for this dummy section.


Right, and that makes it identical to the assembly case.

> As far as I tested, this is working.


Yes, it does.

The problem I was alluding to has to do with symbols generated by the 
linker directly which for some reason behaves differently in that case.

> > > diff --git a/scripts/Makefile.build b/scripts/Makefile.build

> > > index 7f3ca6e..e5ba9b1 100644

> > > --- a/scripts/Makefile.build

> > > +++ b/scripts/Makefile.build

> > > @@ -254,9 +254,18 @@ objtool_dep = $(objtool_obj)                                     \

> > >             $(wildcard include/config/orc/unwinder.h          \

> > >                        include/config/stack/validation.h)

> > >

> > > +ifdef CONFIG_TRIM_UNUSED_KSYMS

> > > +cmd_gen_ksymdeps = \

> > > +     $(CONFIG_SHELL) $(srctree)/scripts/gen_ksymdeps.sh $@ > $(dot-target).tmp; \

> > > +     cat $(dot-target).tmp >> $(dot-target).cmd; \

> > > +     rm -f $(dot-target).tmp;

> >

> > Why don't you append to $(dot-target).cmd directly?

> 

> 

> If scripts/gen_ksymdeps.sh fails for some reasons,

> it will error out immediately thanks to 'set -e' flag.

> 

> Appending incomplete portion might end up with a corrupted .*.cmd file.

> 

> Probably, that would not happen, but I just wanted to ensure it.


Well, strictly speaking, if scripts/gen_ksymdeps.sh fails and its output 
isn't appended at all to the .*.cmd file, then that .*.cmd file is 
already corrupted as it is missing necessary dependencies. Would be 
better to delete the .*.cmd file entirely in that case.


Nicolas
Masahiro Yamada Nov. 20, 2018, 1:13 a.m. UTC | #4
Hi Nicolas,


On Sat, Nov 17, 2018 at 2:50 AM Nicolas Pitre <nicolas.pitre@linaro.org> wrote:

> > > > diff --git a/scripts/Makefile.build b/scripts/Makefile.build

> > > > index 7f3ca6e..e5ba9b1 100644

> > > > --- a/scripts/Makefile.build

> > > > +++ b/scripts/Makefile.build

> > > > @@ -254,9 +254,18 @@ objtool_dep = $(objtool_obj)                                     \

> > > >             $(wildcard include/config/orc/unwinder.h          \

> > > >                        include/config/stack/validation.h)

> > > >

> > > > +ifdef CONFIG_TRIM_UNUSED_KSYMS

> > > > +cmd_gen_ksymdeps = \

> > > > +     $(CONFIG_SHELL) $(srctree)/scripts/gen_ksymdeps.sh $@ > $(dot-target).tmp; \

> > > > +     cat $(dot-target).tmp >> $(dot-target).cmd; \

> > > > +     rm -f $(dot-target).tmp;

> > >

> > > Why don't you append to $(dot-target).cmd directly?

> >

> >

> > If scripts/gen_ksymdeps.sh fails for some reasons,

> > it will error out immediately thanks to 'set -e' flag.

> >

> > Appending incomplete portion might end up with a corrupted .*.cmd file.

> >

> > Probably, that would not happen, but I just wanted to ensure it.

>

> Well, strictly speaking, if scripts/gen_ksymdeps.sh fails and its output

> isn't appended at all to the .*.cmd file, then that .*.cmd file is

> already corrupted as it is missing necessary dependencies. Would be

> better to delete the .*.cmd file entirely in that case.



More strictly speaking, missing necessary dependencies is not a big deal.

Now, scripts/Kbuild.include specifies .DELETE_ON_ERROR

Any error in fixdep, gen_ksymdeps.sh, or whatever
will delete *.o file anyway.

So, I change the course
so that fixdep and gen_ksymdeps.sh directly write to .*.cmd files.


I wrote detailed explanation here:
https://patchwork.kernel.org/patch/10689697/




-- 
Best Regards
Masahiro Yamada
diff mbox series

Patch

diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h
index 4d73e6e..294d6ae 100644
--- a/include/asm-generic/export.h
+++ b/include/asm-generic/export.h
@@ -59,16 +59,19 @@  __kcrctab_\name:
 .endm
 #undef __put
 
-#if defined(__KSYM_DEPS__)
-
-#define __EXPORT_SYMBOL(sym, val, sec)	=== __KSYM_##sym ===
-
-#elif defined(CONFIG_TRIM_UNUSED_KSYMS)
+#if defined(CONFIG_TRIM_UNUSED_KSYMS)
 
 #include <linux/kconfig.h>
 #include <generated/autoksyms.h>
 
+.macro __ksym_marker sym
+	.section ".discard.ksym","a"
+__ksym_marker_\sym:
+	 .previous
+.endm
+
 #define __EXPORT_SYMBOL(sym, val, sec)				\
+	__ksym_marker sym;					\
 	__cond_export_sym(sym, val, sec, __is_defined(__KSYM_##sym))
 #define __cond_export_sym(sym, val, sec, conf)			\
 	___cond_export_sym(sym, val, sec, conf)
diff --git a/include/linux/export.h b/include/linux/export.h
index ce764a5..0413a3d 100644
--- a/include/linux/export.h
+++ b/include/linux/export.h
@@ -92,22 +92,22 @@  struct kernel_symbol {
  */
 #define __EXPORT_SYMBOL(sym, sec)
 
-#elif defined(__KSYM_DEPS__)
+#elif defined(CONFIG_TRIM_UNUSED_KSYMS)
+
+#include <generated/autoksyms.h>
 
 /*
  * For fine grained build dependencies, we want to tell the build system
  * about each possible exported symbol even if they're not actually exported.
- * We use a string pattern that is unlikely to be valid code that the build
- * system filters out from the preprocessor output (see ksym_dep_filter
- * in scripts/Kbuild.include).
+ * We use a symbol pattern __ksym_marker_<symbol> that the build system filters
+ * from the $(NM) output (see scripts/gen_ksymdep.sh). These symbols are
+ * discarded in the final link stage.
  */
-#define __EXPORT_SYMBOL(sym, sec)	=== __KSYM_##sym ===
-
-#elif defined(CONFIG_TRIM_UNUSED_KSYMS)
-
-#include <generated/autoksyms.h>
+#define __ksym_marker(sym)	\
+	static int __ksym_marker_##sym[0] __section(".discard.ksym") __used
 
 #define __EXPORT_SYMBOL(sym, sec)				\
+	__ksym_marker(sym);					\
 	__cond_export_sym(sym, sec, __is_defined(__KSYM_##sym))
 #define __cond_export_sym(sym, sec, conf)			\
 	___cond_export_sym(sym, sec, conf)
diff --git a/scripts/Kbuild.include b/scripts/Kbuild.include
index bb01555..1eafc85 100644
--- a/scripts/Kbuild.include
+++ b/scripts/Kbuild.include
@@ -260,41 +260,12 @@  if_changed_dep = $(if $(strip $(any-prereq) $(arg-check) ),                  \
 	@set -e;                                                             \
 	$(cmd_and_fixdep), @:)
 
-ifndef CONFIG_TRIM_UNUSED_KSYMS
-
 cmd_and_fixdep =                                                             \
 	$(echo-cmd) $(cmd_$(1));                                             \
 	scripts/basic/fixdep $(depfile) $@ '$(make-cmd)' > $(dot-target).tmp;\
 	rm -f $(depfile);                                                    \
 	mv -f $(dot-target).tmp $(dot-target).cmd;
 
-else
-
-# Filter out exported kernel symbol names from the preprocessor output.
-# See also __KSYM_DEPS__ in include/linux/export.h.
-# We disable the depfile generation here, so as not to overwrite the existing
-# depfile while fixdep is parsing it.
-flags_nodeps = $(filter-out -Wp$(comma)-M%, $($(1)))
-ksym_dep_filter =                                                            \
-	case "$(1)" in                                                       \
-	  cc_*_c|cpp_i_c)                                                    \
-	    $(CPP) $(call flags_nodeps,c_flags) -D__KSYM_DEPS__ $< ;;        \
-	  as_*_S|cpp_s_S)                                                    \
-	    $(CPP) $(call flags_nodeps,a_flags) -D__KSYM_DEPS__ $< ;;        \
-	  boot*|build*|cpp_its_S|*cpp_lds_S|dtc|host*|vdso*) : ;;            \
-	  *) echo "Don't know how to preprocess $(1)" >&2; false ;;          \
-	esac | tr ";" "\n" | sed -n 's/^.*=== __KSYM_\(.*\) ===.*$$/_\1/p'
-
-cmd_and_fixdep =                                                             \
-	$(echo-cmd) $(cmd_$(1));                                             \
-	$(ksym_dep_filter) |                                                 \
-		scripts/basic/fixdep -e $(depfile) $@ '$(make-cmd)'          \
-			> $(dot-target).tmp;	                             \
-	rm -f $(depfile);                                                    \
-	mv -f $(dot-target).tmp $(dot-target).cmd;
-
-endif
-
 # Usage: $(call if_changed_rule,foo)
 # Will check if $(cmd_foo) or any of the prerequisites changed,
 # and if so will execute $(rule_foo).
diff --git a/scripts/Makefile.build b/scripts/Makefile.build
index 7f3ca6e..e5ba9b1 100644
--- a/scripts/Makefile.build
+++ b/scripts/Makefile.build
@@ -254,9 +254,18 @@  objtool_dep = $(objtool_obj)					\
 	      $(wildcard include/config/orc/unwinder.h		\
 			 include/config/stack/validation.h)
 
+ifdef CONFIG_TRIM_UNUSED_KSYMS
+cmd_gen_ksymdeps = \
+	$(CONFIG_SHELL) $(srctree)/scripts/gen_ksymdeps.sh $@ > $(dot-target).tmp; \
+	cat $(dot-target).tmp >> $(dot-target).cmd; \
+	rm -f $(dot-target).tmp;
+
+endif
+
 define rule_cc_o_c
 	$(call echo-cmd,checksrc) $(cmd_checksrc)			  \
 	$(call cmd_and_fixdep,cc_o_c)					  \
+	$(cmd_gen_ksymdeps)						  \
 	$(cmd_checkdoc)							  \
 	$(call echo-cmd,objtool) $(cmd_objtool)				  \
 	$(cmd_modversions_c)						  \
@@ -265,6 +274,7 @@  endef
 
 define rule_as_o_S
 	$(call cmd_and_fixdep,as_o_S)					  \
+	$(cmd_gen_ksymdeps)						  \
 	$(call echo-cmd,objtool) $(cmd_objtool)				  \
 	$(cmd_modversions_S)
 endef
diff --git a/scripts/basic/fixdep.c b/scripts/basic/fixdep.c
index 850966f3..facbd60 100644
--- a/scripts/basic/fixdep.c
+++ b/scripts/basic/fixdep.c
@@ -105,8 +105,7 @@ 
 
 static void usage(void)
 {
-	fprintf(stderr, "Usage: fixdep [-e] <depfile> <target> <cmdline>\n");
-	fprintf(stderr, " -e  insert extra dependencies given on stdin\n");
+	fprintf(stderr, "Usage: fixdep <depfile> <target> <cmdline>\n");
 	exit(1);
 }
 
@@ -131,21 +130,6 @@  static void print_dep(const char *m, int slen, const char *dir)
 	printf(".h) \\\n");
 }
 
-static void do_extra_deps(void)
-{
-	char buf[80];
-
-	while (fgets(buf, sizeof(buf), stdin)) {
-		int len = strlen(buf);
-
-		if (len < 2 || buf[len - 1] != '\n') {
-			fprintf(stderr, "fixdep: bad data on stdin\n");
-			exit(1);
-		}
-		print_dep(buf, len - 1, "include/ksym");
-	}
-}
-
 struct item {
 	struct item	*next;
 	unsigned int	len;
@@ -293,7 +277,7 @@  static int is_ignored_file(const char *s, int len)
  * assignments are parsed not only by make, but also by the rather simple
  * parser in scripts/mod/sumversion.c.
  */
-static void parse_dep_file(char *m, const char *target, int insert_extra_deps)
+static void parse_dep_file(char *m, const char *target)
 {
 	char *p;
 	int is_last, is_target;
@@ -369,9 +353,6 @@  static void parse_dep_file(char *m, const char *target, int insert_extra_deps)
 		exit(1);
 	}
 
-	if (insert_extra_deps)
-		do_extra_deps();
-
 	printf("\n%s: $(deps_%s)\n\n", target, target);
 	printf("$(deps_%s):\n", target);
 }
@@ -379,13 +360,9 @@  static void parse_dep_file(char *m, const char *target, int insert_extra_deps)
 int main(int argc, char *argv[])
 {
 	const char *depfile, *target, *cmdline;
-	int insert_extra_deps = 0;
 	void *buf;
 
-	if (argc == 5 && !strcmp(argv[1], "-e")) {
-		insert_extra_deps = 1;
-		argv++;
-	} else if (argc != 4)
+	if (argc != 4)
 		usage();
 
 	depfile = argv[1];
@@ -395,7 +372,7 @@  int main(int argc, char *argv[])
 	printf("cmd_%s := %s\n\n", target, cmdline);
 
 	buf = read_file(depfile);
-	parse_dep_file(buf, target, insert_extra_deps);
+	parse_dep_file(buf, target);
 	free(buf);
 
 	return 0;
diff --git a/scripts/gen_ksymdeps.sh b/scripts/gen_ksymdeps.sh
new file mode 100755
index 0000000..1324986
--- /dev/null
+++ b/scripts/gen_ksymdeps.sh
@@ -0,0 +1,25 @@ 
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+
+set -e
+
+# List of exported symbols
+ksyms=$($NM $1 | sed -n 's/.*__ksym_marker_\(.*\)/\1/p' | tr A-Z a-z)
+
+if [ -z "$ksyms" ]; then
+	exit 0
+fi
+
+echo
+echo "ksymdeps_$1 := \\"
+
+for s in $ksyms
+do
+	echo $s | sed -e 's:^_*:    $(wildcard include/ksym/:' \
+			-e 's:__*:/:g' -e 's/$/.h) \\/'
+done
+
+echo
+echo "$1: \$(ksymdeps_$1)"
+echo
+echo "\$(ksymdeps_$1):"