tools build: Use -fzero-init-padding-bits=all
PATCH RESEND v2 1/1 tools build: Use -fzero-init-padding-bits=all
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit dce4aab8441d ("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.
The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
[1] https://gcc.gnu.org/gcc-15/changes.html
---
Resent to linux-kbuild mailing list.
--- tools/scripts/Makefile.include | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
tools/scripts/Makefile.include +24 -0
@@ -40,6 +40,30 @@ EXTRA_WARNINGS += -Wwrite-strings EXTRA_WARNINGS += -Wformat EXTRA_WARNINGS += -Wno-type-limits +# output directory for tests below +TMPOUT = .tmp_$$$$ + +# try-run +# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise) +# Exit code chooses option. "$$TMP" serves as a temporary file and is +# automatically cleaned up. +try-run = $(shell set -e; \ + TMP=$(TMPOUT)/tmp; \ + trap "rm -rf $(TMPOUT)" EXIT; \ + mkdir -p $(TMPOUT); \ + if ($(1)) >/dev/null 2>&1; \ + then echo "$(2)"; \ + else echo "$(3)"; \ + fi) + +# cc-option +# Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) +cc-option = $(call try-run, \ + $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2)) + +# Explicitly clear padding bits with the initializer '{ 0 }' +CFLAGS += $(call cc-option,-fzero-init-padding-bits=all) + # Makefiles suck: This macro sets a default value of $(2) for the # variable named by $(1), unless the variable has been set by # environment or command line. This is necessary for CC and AR
---
base-commit: 7dff99b354601dd01829e1511711846e04340a69
change-id: 20260224-tools_build_fix_zero_init-dc5261bd8b8b
Best regards,
Signature · 1 line
Leo Yan <[email protected]>
Nathan Chancellor
maintainerHi Leo,
Quoted 21 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 5 lines
[1] https://gcc.gnu.org/gcc-15/changes.html
Signed-off-by Leo Yan <[email protected]>---
Resent to linux-kbuild mailing list.
Kbuild does not maintain/touch tools/. This should go via another tree like perf or something. It does not look like tools/scripts/Makefile.include has a clear owner, perf and bpf tend to be the ones who touch it the most.
Quoted 48 lines
--- tools/scripts/Makefile.include | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)tools/scripts/Makefile.include +24
-1@@ -40,6 +40,30 @@ EXTRA_WARNINGS += -Wwrite-strings EXTRA_WARNINGS += -Wformat EXTRA_WARNINGS += -Wno-type-limits +# output directory for tests below +TMPOUT = .tmp_$$$$ + +# try-run +# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise) +# Exit code chooses option. "$$TMP" serves as a temporary file and is +# automatically cleaned up. +try-run = $(shell set -e; \ + TMP=$(TMPOUT)/tmp; \ + trap "rm -rf $(TMPOUT)" EXIT; \ + mkdir -p $(TMPOUT); \ + if ($(1)) >/dev/null 2>&1; \ + then echo "$(2)"; \ + else echo "$(3)"; \ + fi) + +# cc-option +# Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) +cc-option = $(call try-run, \ + $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2)) + +# Explicitly clear padding bits with the initializer '{ 0 }' +CFLAGS += $(call cc-option,-fzero-init-padding-bits=all) + # Makefiles suck: This macro sets a default value of $(2) for the # variable named by $(1), unless the variable has been set by # environment or command line. This is necessary for CC and AR ---base-commit:
7dff99b354601dd01829e1511711846e04340a69
change-id: 20260224-tools_build_fix_zero_init-dc5261bd8b8bBest regards,
Signature · 1 line
Leo Yan <[email protected]>
Quoted 26 lines · Nathan Chancellor
Hi Leo,
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 3 lines
Signed-off-by Leo Yan <[email protected]>---
Resent to linux-kbuild mailing list.
Kbuilddoes not maintain/touchtools/. This should go via another tree like perf or something. It does not look liketools/scripts/Makefile.includehas a clear owner, perf and bpf tend to be the ones who touch it the most.
You could claim it! ;)
Regardless, I like to see cc-option available here, as I doubt this will be the last conditional option for tool builds. (Actually, are there other conditional options that could use this today in the tools Makefiles?)
-Kees
Quoted 49 lines
Quoted 49 lines
--- tools/scripts/Makefile.include | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)tools/scripts/Makefile.include +24
-1@@ -40,6 +40,30 @@ EXTRA_WARNINGS += -Wwrite-strings EXTRA_WARNINGS += -Wformat EXTRA_WARNINGS += -Wno-type-limits +# output directory for tests below +TMPOUT = .tmp_$$$$ + +# try-run +# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise) +# Exit code chooses option. "$$TMP" serves as a temporary file and is +# automatically cleaned up. +try-run = $(shell set -e; \ + TMP=$(TMPOUT)/tmp; \ + trap "rm -rf $(TMPOUT)" EXIT; \ + mkdir -p $(TMPOUT); \ + if ($(1)) >/dev/null 2>&1; \ + then echo "$(2)"; \ + else echo "$(3)"; \ + fi) + +# cc-option +# Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) +cc-option = $(call try-run, \ + $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2)) + +# Explicitly clear padding bits with the initializer '{ 0 }' +CFLAGS += $(call cc-option,-fzero-init-padding-bits=all) + # Makefiles suck: This macro sets a default value of $(2) for the # variable named by $(1), unless the variable has been set by # environment or command line. This is necessary for CC and AR ---base-commit:
7dff99b354601dd01829e1511711846e04340a69
change-id: 20260224-tools_build_fix_zero_init-dc5261bd8b8bBest regards,
Signature · 1 line
Leo Yan <[email protected]>
Signature · 1 line
Kees Cook
Quoted 27 lines · Kees Cook
Quoted 26 lines · Nathan Chancellor
Hi Leo,
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Signed-off-by Leo Yan <[email protected]>---
Resent to linux-kbuild mailing list.
Kbuilddoes not maintain/touchtools/. This should go via another tree like perf or something. It does not look liketools/scripts/Makefile.includehas a clear owner, perf and bpf tend to be the ones who touch it the most.
This is a circular deadlock. Namhyung (the perf maintainer) advised me to send patch to the linux-kbuild [1], for fixing an union init issue found recently.
Quoted 6 lines
You could claim it! ;)
Regardless, I like to see cc-option available here, as I doubt this will be the last conditional option for tool builds. (Actually, are there other conditional options that could use this today in the tools Makefiles?)
Some subprojects in tools have their own conditional options.
This patch is ambitious that it changes the global Makefile.include file so it can propagate the '-fzero-init-padding-bits=all' option to projects that include it. Why do we need to do this globally? This is because Perf needs to build several subprojects (libperf and bpftool).
Thanks,
Leo
Nathan Chancellor
maintainerQuoted 10 lines · Leo Yan
Quoted 5 lines · Kees Cook
Quoted 4 lines · Nathan Chancellor
Kbuilddoes not maintain/touchtools/. This should go via another tree like perf or something. It does not look liketools/scripts/Makefile.includehas a clear owner, perf and bpf tend to be the ones who touch it the most.This is a circular deadlock. Namhyung (the perf maintainer) advised me to send patch to the linux-kbuild [1], for fixing an union init issue found recently.
The tools/ build system is not Kbuild, so I do not want to take patches for it, sorry. Issues from patches I take become my responsibility to deal with and I am not at all familiar with the tools build system because I am not a consumer of it. Nicolas may feel differently but I am going to assume not based on his level of expertise with tools/ [1]. I am not trying to deadlock you though.
Namhyung, I think this patch can reasonably go via the perf tree since it will be a primary consumer of it.
Quoted 1 line
Quoted 1 line
You could claim it! ;)
Heh, Kbuild and ClangBuiltLinux give me more than enough to do around here ;)
Quoted 11 lines
Quoted 4 lines
Regardless, I like to see cc-option available here, as I doubt this will be the last conditional option for tool builds. (Actually, are there other conditional options that could use this today in the tools Makefiles?)
Some subprojects in tools have their own conditional options.
This patch is ambitious that it changes the global Makefile.include file so it can propagate the '-fzero-init-padding-bits=all' option to projects that include it. Why do we need to do this globally? This is because Perf needs to build several subprojects (libperf and bpftool).
This seems like a great reason for it to go via the perf tree as noted above.
[1]: https://lore.kernel.org/aNhGp7NDCCrtwJqm@levanger/
Cheers,
Nathan
Hello,
Quoted 19 lines · Nathan Chancellor
Quoted 10 lines · Leo Yan
Quoted 5 lines · Kees Cook
Quoted 4 lines · Nathan Chancellor
Kbuilddoes not maintain/touchtools/. This should go via another tree like perf or something. It does not look liketools/scripts/Makefile.includehas a clear owner, perf and bpf tend to be the ones who touch it the most.This is a circular deadlock. Namhyung (the perf maintainer) advised me to send patch to the linux-kbuild [1], for fixing an union init issue found recently.
The
tools/build system is notKbuild, so I do not want to take patches for it, sorry. Issues from patches I take become my responsibility to deal with and I am not at all familiar with the tools build system because I am not a consumer of it. Nicolas may feel differently but I am going to assume not based on his level of expertise withtools/[1]. I am not trying to deadlock you though.
Quoted 2 lines
Namhyung, I think this patch can reasonably go via the perf tree since it will be a primary consumer of it.
Sorry for the trouble. I'm fine to take it to the perf tree once everyone involved is happy about it. Let me CC the bpf list in the original patch.
Thanks,
Namhyung
Quoted 25 lines
Quoted 2 lines
Quoted 2 lines
You could claim it! ;)
Heh,
Kbuildand ClangBuiltLinux give me more than enough to do around here ;)Quoted 11 lines
Quoted 4 lines
Regardless, I like to see cc-option available here, as I doubt this will be the last conditional option for tool builds. (Actually, are there other conditional options that could use this today in the tools Makefiles?)
Some subprojects in tools have their own conditional options.
This patch is ambitious that it changes the global Makefile.include file so it can propagate the '-fzero-init-padding-bits=all' option to projects that include it. Why do we need to do this globally? This is because Perf needs to build several subprojects (libperf and bpftool).
This seems like a great reason for it to go via the perf tree as noted above.
[1]: https://lore.kernel.org/aNhGp7NDCCrtwJqm@levanger/
Cheers,
Nathan
Adding bpftool maintainer.
Quoted 74 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
[1] https://gcc.gnu.org/gcc-15/changes.html
Signed-off-by Leo Yan <[email protected]>---
Resent to linux-kbuild mailing list.--- tools/scripts/Makefile.include | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)tools/scripts/Makefile.include +24
-1@@ -40,6 +40,30 @@ EXTRA_WARNINGS += -Wwrite-strings EXTRA_WARNINGS += -Wformat EXTRA_WARNINGS += -Wno-type-limits +# output directory for tests below +TMPOUT = .tmp_$$$$ + +# try-run +# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise) +# Exit code chooses option. "$$TMP" serves as a temporary file and is +# automatically cleaned up. +try-run = $(shell set -e; \ + TMP=$(TMPOUT)/tmp; \ + trap "rm -rf $(TMPOUT)" EXIT; \ + mkdir -p $(TMPOUT); \ + if ($(1)) >/dev/null 2>&1; \ + then echo "$(2)"; \ + else echo "$(3)"; \ + fi) + +# cc-option +# Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) +cc-option = $(call try-run, \ + $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2)) + +# Explicitly clear padding bits with the initializer '{ 0 }' +CFLAGS += $(call cc-option,-fzero-init-padding-bits=all) + # Makefiles suck: This macro sets a default value of $(2) for the # variable named by $(1), unless the variable has been set by # environment or command line. This is necessary for CC and AR ---base-commit:
7dff99b354601dd01829e1511711846e04340a69
change-id: 20260224-tools_build_fix_zero_init-dc5261bd8b8bBest regards,
Signature · 1 line
Leo Yan <[email protected]>
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 27 lines
Adding bpftool maintainer.
Quoted 24 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
[1] https://gcc.gnu.org/gcc-15/changes.html
Signed-off-by Leo Yan <[email protected]>
Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
One potential concern (I didn't try) could be for cross-compilation:
bpftool's Makefile sets HOST_CFLAGS based on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example. The same concern could apply to perf with HOSTCFLAGS, by the way?
Best regards,
Quentin
Note: For fellow bpf@ readers, the original thread is at
https://lore.kernel.org/linux-kbuild/[email protected]/T/#m700907de1a84c007bfda62981af590ad7aed0f11
Quoted 27 lines · Quentin Monnet
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 26 lines
Adding bpftool maintainer.
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 1 line
Quoted 1 line
Signed-off-by Leo Yan <[email protected]>Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
Thanks a lot for testing!
Quoted 3 lines
One potential concern (I didn't try) could be for cross-compilation:
bpftool'sMakefilesetsHOST_CFLAGSbased on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example.
To avoid confusion, we can use EXTRA_CFLAGS and HOST_EXTRACFLAGS instead in Makefile.include:
-----
# cc-option
# Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586)
cc-option = $(call try-run, \
$(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))host-cc-option = $(call try-run, \
$(HOSTCC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))# Explicitly clear padding bits with the initializer '{ 0 }' EXTRA_CFLAGS += $(call cc-option,-fzero-init-padding-bits=all) HOST_EXTRACFLAGS += $(call host-cc-option,-fzero-init-padding-bits=all)
-----
Then, in a project, its Makefile can append EXTRA_CFLAGS and HOST_EXTRACFLAGS to CFLAGS and HOSTCFLAGS respectively.
If this is fine for us, I will repin patches
Quoted 1 line
The same concern could apply to perf with HOSTCFLAGS, by the way?
I don't see perf's HOSTCFLAGS to reuse CFLAGS.
Thanks,
Leo
2026-02-27 10:36 UTC+0000 ~ Leo Yan <[email protected]>
Quoted 56 lines · Quentin Monnet
Quoted 27 lines
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 26 lines
Adding bpftool maintainer.
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 1 line
Quoted 1 line
Signed-off-by Leo Yan <[email protected]>Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
Thanks a lot for testing!
Quoted 3 lines
One potential concern (I didn't try) could be for cross-compilation:
bpftool'sMakefilesetsHOST_CFLAGSbased on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example.To avoid confusion, we can use
EXTRA_CFLAGSandHOST_EXTRACFLAGSinstead in Makefile.include:-----
# cc-option # Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) cc-option = $(call try-run, \ $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))host-cc-option = $(call try-run, \ $(HOSTCC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))
Quoted 8 lines
# Explicitly clear padding bits with the initializer '{ 0 }'
EXTRA_CFLAGS+= $(call cc-option,-fzero-init-padding-bits=all)HOST_EXTRACFLAGS+= $(call host-cc-option,-fzero-init-padding-bits=all)-----
Then, in a project, its
Makefilecan appendEXTRA_CFLAGSandHOST_EXTRACFLAGSto CFLAGS and HOSTCFLAGS respectively.
This sounds like it should work for bpftool as long as we += and don't overwrite the EXTRA_CFLAGS passed from command line. In bpftool's Makefile we'd have to move HOST_CFLAGS's CFLAGS-based defintion higher up, before we add the EXTRA_CFLAGS to CFLAGS; and if anything needs to be passed to the host binary, users will have to specify HOST_EXTRACFLAGS (or HOST_EXTRA_CFLAGS?) independently, which is acceptable.
Out of curiosity I looked at other tools, and of course everyone does it differently:
- Some of them, like bpftool, reuse the CFLAGS inherited from tools/scripts/Makefile.include, adding EXTRA_CFLAGS to it, so setting aside cross-compiling, both approaches (using CFLAGS or EXTRA_CFLAGS) are fine.
- Some of them, such as tools/lib/bpf/Makefile for example, reset CFLAGS before/by adding EXTRA_CFLAGS, so your v2 relying on CFLAGS would probably have no effect for them.
- Some of them, such as tools/tracing/latency/Makefile or tools/mm/Makefile, do not use EXTRA_CFLAGS - maybe it's worth adding it if your objective is to pass the flag to all/most tools.
- (Also many smaller Makefiles such as most of the ones in selftests do not pull tools/scripts/Makefile.include at all, but I suppose this is out of scope.)
Quoted 5 lines
If this is fine for us, I will repin patches
Quoted 1 line
The same concern could apply to perf with HOSTCFLAGS, by the way?
I don't see perf's HOSTCFLAGS to reuse CFLAGS.
Woops I can't see the HOSTCFLAGS using the CFLAGS either for perf, sorry about that.
Thanks,
Quentin
Hello,
Quoted 67 lines · Quentin Monnet
2026-02-27 10:36 UTC+0000 ~ Leo Yan <[email protected]>
Quoted 56 lines · Quentin Monnet
Quoted 27 lines
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 26 lines
Adding bpftool maintainer.
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 1 line
Quoted 1 line
Signed-off-by Leo Yan <[email protected]>Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
Thanks a lot for testing!
Quoted 3 lines
One potential concern (I didn't try) could be for cross-compilation:
bpftool'sMakefilesetsHOST_CFLAGSbased on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example.To avoid confusion, we can use
EXTRA_CFLAGSandHOST_EXTRACFLAGSinstead in Makefile.include:-----
# cc-option # Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) cc-option = $(call try-run, \ $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))host-cc-option = $(call try-run, \ $(HOSTCC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))Quoted 8 lines
# Explicitly clear padding bits with the initializer '{ 0 }'
EXTRA_CFLAGS+= $(call cc-option,-fzero-init-padding-bits=all)HOST_EXTRACFLAGS+= $(call host-cc-option,-fzero-init-padding-bits=all)-----
Then, in a project, its
Makefilecan appendEXTRA_CFLAGSandHOST_EXTRACFLAGSto CFLAGS and HOSTCFLAGS respectively.
Quoted 6 lines
This sounds like it should work for bpftool as long as we += and don't overwrite the
EXTRA_CFLAGSpassed from command line. In bpftool'sMakefilewe'd have to move HOST_CFLAGS's CFLAGS-based defintion higher up, before we add theEXTRA_CFLAGSto CFLAGS; and if anything needs to be passed to the host binary, users will have to specifyHOST_EXTRACFLAGS(orHOST_EXTRA_CFLAGS?) independently, which is acceptable.
Quentin, do you want v2 with this or just ok for v1?
Thanks,
Namhyung
Quoted 34 lines
Out of curiosity I looked at other tools, and of course everyone does it differently:
- Some of them, like bpftool, reuse the CFLAGS inherited from
tools/scripts/Makefile.include, addingEXTRA_CFLAGSto it, so setting aside cross-compiling, both approaches (using CFLAGS orEXTRA_CFLAGS) are fine.- Some of them, such as
tools/lib/bpf/Makefilefor example, reset CFLAGS before/by addingEXTRA_CFLAGS, so your v2 relying on CFLAGS would probably have no effect for them.- Some of them, such as
tools/tracing/latency/Makefileortools/mm/Makefile, do not useEXTRA_CFLAGS- maybe it's worth adding it if your objective is to pass the flag to all/most tools.- (Also many smaller Makefiles such as most of the ones in selftests do not pull
tools/scripts/Makefile.includeat all, but I suppose this is out of scope.)Quoted 5 lines
If this is fine for us, I will repin patches
Quoted 1 line
The same concern could apply to perf with HOSTCFLAGS, by the way?
I don't see perf's HOSTCFLAGS to reuse CFLAGS.
Woops I can't see the HOSTCFLAGS using the CFLAGS either for perf, sorry about that.
Thanks,
Quentin
2026-03-03 17:14 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 77 lines
Hello,
Quoted 67 lines · Quentin Monnet
2026-02-27 10:36 UTC+0000 ~ Leo Yan <[email protected]>
Quoted 56 lines · Quentin Monnet
Quoted 27 lines
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 26 lines
Adding bpftool maintainer.
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 1 line
Quoted 1 line
Signed-off-by Leo Yan <[email protected]>Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
Thanks a lot for testing!
Quoted 3 lines
One potential concern (I didn't try) could be for cross-compilation:
bpftool'sMakefilesetsHOST_CFLAGSbased on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example.To avoid confusion, we can use
EXTRA_CFLAGSandHOST_EXTRACFLAGSinstead in Makefile.include:-----
# cc-option # Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) cc-option = $(call try-run, \ $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))host-cc-option = $(call try-run, \ $(HOSTCC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))Quoted 8 lines
# Explicitly clear padding bits with the initializer '{ 0 }'
EXTRA_CFLAGS+= $(call cc-option,-fzero-init-padding-bits=all)HOST_EXTRACFLAGS+= $(call host-cc-option,-fzero-init-padding-bits=all)-----
Then, in a project, its
Makefilecan appendEXTRA_CFLAGSandHOST_EXTRACFLAGSto CFLAGS and HOSTCFLAGS respectively.Quoted 6 lines
This sounds like it should work for bpftool as long as we += and don't overwrite the
EXTRA_CFLAGSpassed from command line. In bpftool'sMakefilewe'd have to move HOST_CFLAGS's CFLAGS-based defintion higher up, before we add theEXTRA_CFLAGSto CFLAGS; and if anything needs to be passed to the host binary, users will have to specifyHOST_EXTRACFLAGS(orHOST_EXTRA_CFLAGS?) independently, which is acceptable.
Quoted 4 lines
Quentin, do you want v2 with this or just ok for v1?
Thanks,
Namhyung
Hi Namhyung
(I'm not entirely sure what v1/v2 refer to, this one was tagged v2 and I suspect v1 was the first post before the resend - I suppose you mean this one is v1 and a v2 would be with an additional host variable.)
I don't want bpftool's HOST_CFLAGS to inherit -fzero-init-padding-bits=all if the compiler doesn't support it, which may happen with the current version of the patch. I'd prefer a version with separate EXTRA_CFLAGS and HOST_EXTRA_CFLAGS, as proposed by Leo and discussed above, to address the cross-compilation issue.
Thanks,
Quentin
Quoted 84 lines · Quentin Monnet
2026-03-03 17:14 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 77 lines
Hello,
Quoted 67 lines · Quentin Monnet
2026-02-27 10:36 UTC+0000 ~ Leo Yan <[email protected]>
Quoted 56 lines · Quentin Monnet
Quoted 27 lines
2026-02-26 10:38 UTC-0800 ~ Namhyung Kim <[email protected]>
Quoted 26 lines
Adding bpftool maintainer.
Quoted 23 lines · Leo Yan
GCC-15 release claims [1]:
{0} initializer in C or C++ for unions no longer guarantees clearing of the whole union (except for static storage duration initialization), it just initializes the first union member to zero. If initialization of the whole union including padding bits is desirable, use {} (valid in C23 or C++) or use -fzero-init-padding-bits=unions option to restore old GCC behavior.
As a result, this new behaviour might cause unexpected data when we initialize a union with using the '{ 0 }' initializer.
Since commit
dce4aab8441d("kbuild: Use -fzero-init-padding-bits=all"), the kernel has enabled -fzero-init-padding-bits=all to zero padding bits in unions and structures. This commit applies the same option for tools building.The option is not supported neither by any version older than GCC 15 and is also not supported by LLVM, this patch adds the cc-option function to dynamically detect the compiler option.
Quoted 8 lines
Quoted 1 line
Quoted 1 line
Signed-off-by Leo Yan <[email protected]>Thank you Namhyung for the Cc.
I built bpftool with the patch, with gcc 13 (which didn't get the flag, as expected) and gcc 15, and it's fine with both. As far as I can tell, bpftool does not initialise any union with "{0}" anyway.
Thanks a lot for testing!
Quoted 3 lines
One potential concern (I didn't try) could be for cross-compilation:
bpftool'sMakefilesetsHOST_CFLAGSbased on $(CFLAGS), but $(HOSTCC) and $(CC) could be different versions of gcc, for example.To avoid confusion, we can use
EXTRA_CFLAGSandHOST_EXTRACFLAGSinstead in Makefile.include:-----
# cc-option # Usage: CFLAGS += $(call cc-option,-march=winchip-c6,-march=i586) cc-option = $(call try-run, \ $(CC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))host-cc-option = $(call try-run, \ $(HOSTCC) -Werror $(1) -c -x c /dev/null -o "$$TMP",$(1),$(2))Quoted 8 lines
# Explicitly clear padding bits with the initializer '{ 0 }'
EXTRA_CFLAGS+= $(call cc-option,-fzero-init-padding-bits=all)HOST_EXTRACFLAGS+= $(call host-cc-option,-fzero-init-padding-bits=all)-----
Then, in a project, its
Makefilecan appendEXTRA_CFLAGSandHOST_EXTRACFLAGSto CFLAGS and HOSTCFLAGS respectively.Quoted 6 lines
This sounds like it should work for bpftool as long as we += and don't overwrite the
EXTRA_CFLAGSpassed from command line. In bpftool'sMakefilewe'd have to move HOST_CFLAGS's CFLAGS-based defintion higher up, before we add theEXTRA_CFLAGSto CFLAGS; and if anything needs to be passed to the host binary, users will have to specifyHOST_EXTRACFLAGS(orHOST_EXTRA_CFLAGS?) independently, which is acceptable.Quoted 4 lines
Quentin, do you want v2 with this or just ok for v1?
Thanks,
Namhyung
Quoted 5 lines
Hi Namhyung
(I'm not entirely sure what v1/v2 refer to, this one was tagged v2 and I suspect v1 was the first post before the resend - I suppose you mean this one is v1 and a v2 would be with an additional host variable.)
Oops, right. They should be v2 and v3.
Quoted 6 lines
I don't want bpftool's
HOST_CFLAGSto inherit -fzero-init-padding-bits=all if the compiler doesn't support it, which may happen with the current version of the patch. I'd prefer a version with separateEXTRA_CFLAGSandHOST_EXTRA_CFLAGS, as proposed by Leo and discussed above, to address the cross-compilation issue.
Got it. Leo, can you please update the patch?
Thanks,
Namhyung
On Tue, Mar 03, 2026 at 05:35:04PM -0800, Namhyung Kim wrote:
[...]
Quoted 7 lines
Quoted 5 lines
I don't want bpftool's
HOST_CFLAGSto inherit -fzero-init-padding-bits=all if the compiler doesn't support it, which may happen with the current version of the patch. I'd prefer a version with separateEXTRA_CFLAGSandHOST_EXTRA_CFLAGS, as proposed by Leo and discussed above, to address the cross-compilation issue.Got it. Leo, can you please update the patch?
Yes, I will prepare a new patch series.
Also thanks Quentin's detailed suggestions.
Leo