Makefile: Add '-fno-builtin-bcmp' to CLANG_FLAGS
Subsystems (4)
PATCH 1/1 Makefile: Add '-fno-builtin-bcmp' to CLANG_FLAGS
After LLVM revision r355672 [1], all known working kernel configurations fail to link [2]:
ld: init/do_mounts.o: in function `prepare_namespace':
do_mounts.c:(.init.text+0x5ca): undefined reference to `bcmp'
ld: do_mounts.c:(.init.text+0x5e6): undefined reference to `bcmp'
ld: init/initramfs.o: in function `do_header':
initramfs.c:(.init.text+0x6e0): undefined reference to `bcmp'
ld: initramfs.c:(.init.text+0x6f8): undefined reference to `bcmp'
ld: arch/x86/kernel/setup.o: in function `setup_arch':
setup.c:(.init.text+0x21d): undefined reference to `bcmp'
Commit 6edfba1b33c7 ("[PATCH] x86_64: Don't define string functions to builtin") removed '-ffreestanding' globally and the kernel doesn't provide a bcmp definition so the linker cannot find a reference to it.
Fix this by explicitly telling LLVM through Clang not to emit bcmp references. This flag does not need to be behind 'cc-option' because all working versions of Clang support this flag.
[1]: https://github.com/llvm/llvm-project/commit/8e16d73346f8091461319a7dfc4ddd18eedcff13
[2]: https://travis-ci.com/ClangBuiltLinux/continuous-integration/builds/104027249
--- Makefile | 1 + 1 file changed, 1 insertion(+)
Makefile +1 -0
@@ -501,6 +501,7 @@ ifneq ($(GCC_TOOLCHAIN),) CLANG_FLAGS += --gcc-toolchain=$(GCC_TOOLCHAIN) endif CLANG_FLAGS += -no-integrated-as +CLANG_FLAGS += -fno-builtin-bcmp KBUILD_CFLAGS += $(CLANG_FLAGS) KBUILD_AFLAGS += $(CLANG_FLAGS) export CLANG_FLAGS
Signature · 1 line
2.21.0
Quoted 21 lines · Nathan Chancellor
After LLVM revision r355672 [1], all known working kernel configurations fail to link [2]:
ld:
init/do_mounts.o: in function `prepare_namespace':
do_mounts.c:(.init.text+0x5ca): undefined reference to `bcmp'
ld: do_mounts.c:(.init.text+0x5e6): undefined reference to `bcmp'
ld:init/initramfs.o: in function `do_header':
initramfs.c:(.init.text+0x6e0): undefined reference to `bcmp'
ld: initramfs.c:(.init.text+0x6f8): undefined reference to `bcmp'
ld:arch/x86/kernel/setup.o: in function `setup_arch':
setup.c:(.init.text+0x21d): undefined reference to `bcmp'Commit
6edfba1b33c7("[PATCH]x86_64: Don't define string functions to builtin") removed '-ffreestanding' globally and the kernel doesn't provide a bcmp definition so the linker cannot find a reference to it.Fix this by explicitly telling LLVM through Clang not to emit bcmp references. This flag does not need to be behind 'cc-option' because all working versions of Clang support this flag.
Quoted 7 lines
[1]: https://github.com/llvm/llvm-project/commit/8e16d73346f8091461319a7dfc4ddd18eedcff13
[2]: https://travis-ci.com/ClangBuiltLinux/continuous-integration/builds/104027249
Thanks for this patch. Can the maintainers please consider this an emergency patch; without it, the recent change to LLVM has caused ALL of our CI targets to go red.
Quoted 17 lines
--- Makefile | 1 + 1 file changed, 1 insertion(+)Makefile +1
-1@@ -501,6 +501,7 @@ ifneq ($(GCC_TOOLCHAIN),) CLANG_FLAGS += --gcc-toolchain=$(GCC_TOOLCHAIN) endif CLANG_FLAGS += -no-integrated-as +CLANG_FLAGS += -fno-builtin-bcmp KBUILD_CFLAGS += $(CLANG_FLAGS) KBUILD_AFLAGS += $(CLANG_FLAGS) export CLANG_FLAGS --
Quoted 2 lines
2.21.0
--
Thanks,
~Nick Desaulniers
Quoted 12 lines · Nathan Chancellor
After LLVM revision r355672 [1], all known working kernel configurations fail to link [2]:
ld:
init/do_mounts.o: in function `prepare_namespace':
do_mounts.c:(.init.text+0x5ca): undefined reference to `bcmp'
ld: do_mounts.c:(.init.text+0x5e6): undefined reference to `bcmp'
ld:init/initramfs.o: in function `do_header':
initramfs.c:(.init.text+0x6e0): undefined reference to `bcmp'
ld: initramfs.c:(.init.text+0x6f8): undefined reference to `bcmp'
ld:arch/x86/kernel/setup.o: in function `setup_arch':
setup.c:(.init.text+0x21d): undefined reference to `bcmp'
Quoted 8 lines
Commit
6edfba1b33c7("[PATCH]x86_64: Don't define string functions to builtin") removed '-ffreestanding' globally and the kernel doesn't provide a bcmp definition so the linker cannot find a reference to it.Fix this by explicitly telling LLVM through Clang not to emit bcmp references. This flag does not need to be behind 'cc-option' because all working versions of Clang support this flag.
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Rasmus
Quoted 23 lines · Rasmus Villemoes
Quoted 12 lines · Nathan Chancellor
After LLVM revision r355672 [1], all known working kernel configurations fail to link [2]:
ld:
init/do_mounts.o: in function `prepare_namespace':
do_mounts.c:(.init.text+0x5ca): undefined reference to `bcmp'
ld: do_mounts.c:(.init.text+0x5e6): undefined reference to `bcmp'
ld:init/initramfs.o: in function `do_header':
initramfs.c:(.init.text+0x6e0): undefined reference to `bcmp'
ld: initramfs.c:(.init.text+0x6f8): undefined reference to `bcmp'
ld:arch/x86/kernel/setup.o: in function `setup_arch':
setup.c:(.init.text+0x21d): undefined reference to `bcmp'Quoted 8 lines
Commit
6edfba1b33c7("[PATCH]x86_64: Don't define string functions to builtin") removed '-ffreestanding' globally and the kernel doesn't provide a bcmp definition so the linker cannot find a reference to it.Fix this by explicitly telling LLVM through Clang not to emit bcmp references. This flag does not need to be behind 'cc-option' because all working versions of Clang support this flag.
Quoted 5 lines
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
I also thought of this.
Signature · 2 lines
Best Regards Masahiro Yamada
Quoted 22 lines · Rasmus Villemoes
Quoted 12 lines · Nathan Chancellor
After LLVM revision r355672 [1], all known working kernel configurations fail to link [2]:
ld:
init/do_mounts.o: in function `prepare_namespace':
do_mounts.c:(.init.text+0x5ca): undefined reference to `bcmp'
ld: do_mounts.c:(.init.text+0x5e6): undefined reference to `bcmp'
ld:init/initramfs.o: in function `do_header':
initramfs.c:(.init.text+0x6e0): undefined reference to `bcmp'
ld: initramfs.c:(.init.text+0x6f8): undefined reference to `bcmp'
ld:arch/x86/kernel/setup.o: in function `setup_arch':
setup.c:(.init.text+0x21d): undefined reference to `bcmp'Quoted 8 lines
Commit
6edfba1b33c7("[PATCH]x86_64: Don't define string functions to builtin") removed '-ffreestanding' globally and the kernel doesn't provide a bcmp definition so the linker cannot find a reference to it.Fix this by explicitly telling LLVM through Clang not to emit bcmp references. This flag does not need to be behind 'cc-option' because all working versions of Clang support this flag.
Quoted 7 lines
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Rasmus
Hi Rasmus,
Thank you much for the review, I didn't even realize this was possible :)
I'd certainly like to explore it as that is what glibc does. How would you suggest going about it here?
Thanks,
Nathan
Quoted 11 lines · Nathan Chancellor
Quoted 5 lines · Rasmus Villemoes
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Thank you much for the review, I didn't even realize this was possible :)
I'd certainly like to explore it as that is what glibc does. How would you suggest going about it here?
I suggested a possible implementation (likely contains bugs) and an alias for architectures that require strict alignment, see
https://bugs.llvm.org/show_bug.cgi?id=41035#c11
We could start out with just the alias.
Arnd
Quoted 14 lines · Arnd Bergmann
Quoted 11 lines · Nathan Chancellor
Quoted 5 lines · Rasmus Villemoes
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Thank you much for the review, I didn't even realize this was possible :)
I'd certainly like to explore it as that is what glibc does. How would you suggest going about it here?
Quoted 7 lines
I suggested a possible implementation (likely contains bugs) and an alias for architectures that require strict alignment, see
https://bugs.llvm.org/show_bug.cgi?id=41035#c11We could start out with just the alias.
Arnd
So I've been messing around with this for a bit (forgive me, I'm still learning all of the intricacies around here) and this is what I came up with for when __ARCH_HAVE_MEMCMP is unset (not particularly difficult obviously). I can compile, link, and boot an x86 in QEMU.
However, I am not sure how to handle memcmp definitions that are written in assembly like arm64, as the alias attribute only works when the alias is defined in the same translation unit. Thoughts?
Cheers,
Nathan
========================================
lib/string.c +3 -0
@@ -864,6 +864,9 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)return res; }EXPORT_SYMBOL (memcmp); + +int bcmp(const void *cs, const void *ct, size_t count) __weak __alias(memcmp); +EXPORT_SYMBOL (bcmp );#endif #ifndef __HAVE_ARCH_MEMSCAN
Quoted 24 lines · Nathan Chancellor
Quoted 14 lines · Arnd Bergmann
Quoted 11 lines · Nathan Chancellor
Quoted 5 lines · Rasmus Villemoes
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Thank you much for the review, I didn't even realize this was possible :)
I'd certainly like to explore it as that is what glibc does. How would you suggest going about it here?
Quoted 7 lines
I suggested a possible implementation (likely contains bugs) and an alias for architectures that require strict alignment, see
https://bugs.llvm.org/show_bug.cgi?id=41035#c11We could start out with just the alias.
Arnd
Quoted 8 lines
So I've been messing around with this for a bit (forgive me, I'm still learning all of the intricacies around here) and this is what I came up with for when
__ARCH_HAVE_MEMCMPis unset (not particularly difficult obviously). I can compile, link, and boot an x86 in QEMU.However, I am not sure how to handle memcmp definitions that are written in assembly like arm64, as the alias attribute only works when the alias is defined in the same translation unit. Thoughts?
I hit this, too:./arch/arm64/include/asm/string.h:40:15: error: alias must point to a defined variable
or function
since memcmp is only declared (not defined) in that header, clang is not happy to alias to memcmp. If __HAVE_ARCH_MEMCMP is defined, then we can just return a call to memcmp. Thoughts (I need to add comments above bcmp, anything else)? Do we like the typeof trick (stolen from glibc) or no?
lib/string.c +7 -1
@@ -845,7 +845,13 @@ void *memmove(void *dest, const void *src, size_t count)EXPORT_SYMBOL (memmove);#endif -#ifndef __HAVE_ARCH_MEMCMP +#ifdef __HAVE_ARCH_MEMCMP +int bcmp (const void *cs,const void *ct,size_t n) +{ +return memcmp (cs, ct, n); +} +EXPORT_SYMBOL (bcmp); +#else /** * memcmp - Compare two areas of memory * @cs: One area of memory
@@ -864,6 +870,8 @@ __visible int memcmp(const void *cs, const void
*ct, size_t count)
return res;
}
EXPORT_SYMBOL(memcmp);
+__weak __alias(memcmp) typeof(memcmp) bcmp;
+EXPORT_SYMBOL(bcmp);
#endif
#ifndef __HAVE_ARCH_MEMSCAN
Signature · 2 lines
Thanks, ~Nick Desaulniers
Quoted 75 lines · Nick Desaulniers
Quoted 24 lines · Nathan Chancellor
Quoted 14 lines · Arnd Bergmann
Quoted 11 lines · Nathan Chancellor
Quoted 5 lines · Rasmus Villemoes
Wouldn't it be better to just define bcmp as an alias for memcmp? They seem to have compatible prototypes, and then somebody might someday sit down and implement some word-at-a-time version of bcmp making use of the weaker guarantees about the return value to gain some performance. But I suppose that can also be done later.
Thank you much for the review, I didn't even realize this was possible :)
I'd certainly like to explore it as that is what glibc does. How would you suggest going about it here?
Quoted 7 lines
I suggested a possible implementation (likely contains bugs) and an alias for architectures that require strict alignment, see
https://bugs.llvm.org/show_bug.cgi?id=41035#c11We could start out with just the alias.
Arnd
Quoted 8 lines
So I've been messing around with this for a bit (forgive me, I'm still learning all of the intricacies around here) and this is what I came up with for when
__ARCH_HAVE_MEMCMPis unset (not particularly difficult obviously). I can compile, link, and boot an x86 in QEMU.However, I am not sure how to handle memcmp definitions that are written in assembly like arm64, as the alias attribute only works when the alias is defined in the same translation unit. Thoughts?
I hit this, too:
./arch/arm64/include/asm/string.h:40:15: error: alias must point to a defined variable
or functionsince memcmp is only declared (not defined) in that header, clang is not happy to alias to memcmp. If
__HAVE_ARCH_MEMCMPis defined, then we can just return a call to memcmp. Thoughts (I need to add comments above bcmp, anything else)? Do we like the typeof trick (stolen from glibc) or no?lib/string.c +9
-1@@ -845,7 +845,13 @@ void *memmove(void *dest, const void *src, size_t count)EXPORT_SYMBOL (memmove);#endif -#ifndef __HAVE_ARCH_MEMCMP +#ifdef __HAVE_ARCH_MEMCMP +int bcmp (const void *cs,const void *ct,size_t n) +{ +return memcmp (cs, ct, n); +} +EXPORT_SYMBOL (bcmp); +#else /** * memcmp - Compare two areas of memory * @cs: One area of memory @@ -864,6 +870,8 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)return res; }EXPORT_SYMBOL (memcmp); +__weak __alias(memcmp) typeof(memcmp) bcmp; +EXPORT_SYMBOL(bcmp);#endif
Quoted 1 line
#ifndef
__HAVE_ARCH_MEMSCAN
Alternatively, just not worrying about __alias makes this simpler and seems to work (need to add comments, thoughts?):
lib/string.c +0 -0
@@ -866,6 +866,15 @@ __visible int memcmp(const void *cs, const void
*ct, size_t count)
EXPORT_SYMBOL(memcmp);
#endif
+#ifndef __HAVE_ARCH_BCMP
+#undef bcmp
+int bcmp(const void *cs, const void *ct, size_t count) +{
+ return memcmp(cs, ct, count);
+}
+EXPORT_SYMBOL(bcmp);
+#endif
+
#ifndef __HAVE_ARCH_MEMSCAN
/**
* memscan - Find a character in an area of memory.
Signature · 2 lines
Thanks, ~Nick Desaulniers
PATCH 1/1 lib/string.c: implement a basic bcmp
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
--- lib/string.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
lib/string.c +15 -0
@@ -866,6 +866,21 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - Like memcmp but the return code simply indicates a non-match. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory.
Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH] lib/string.c: implement a basic bcmp
Quoted 33 lines · Nick Desaulniers
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.Reported-by Nathan Chancellor <[email protected]>Reported-by Adhemerval Zanella <[email protected]>Suggested-by Arnd Bergmann <[email protected]>Suggested-by James Y Knight <[email protected]>Suggested-by Masahiro Yamada <[email protected]>Suggested-by Nathan Chancellor <[email protected]>Suggested-by Rasmus Villemoes <[email protected]>Signed-off-by Nick Desaulniers <[email protected]>
Quoted 2 lines
--- lib/string.c | 15 +++++++++++++++
ah, looks like I should provide a declaration in include/linux/string.h, too, in case others within the kernel would like to use bcmp. WIll send a v2.
Quoted 31 lines
1 file changed, 15 insertions(+)lib/string.c +15
-1@@ -866,6 +866,21 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - Like memcmp but the return code simply indicates a non-match. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory. -- 2.21.0.360.g471c308f928-goog
Signature · 2 lines
Thanks, ~Nick Desaulniers
PATCH v2 1/1 lib/string.c: implement a basic bcmp
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
---
Changes V1 -> V2:
* Add declaration to include/linux/string.h.
* Reword comment above bcmp.
include/linux/string.h | 3 +++ lib/string.c | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
include/linux/string.h +3 -0
@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif
lib/string.c +15 -0
@@ -866,6 +866,21 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - Like memcmp but a non-zero return code simply indicates a non-match. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory.
Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH v2] lib/string.c: implement a basic bcmp
lib/string.c __visible int memcmp(const void *cs, const void *ct, size_t count) · line 879
Quoted 11 lines · On Wed, 13 Mar 2019 11:17:15 -0700 Nick Desaulniers <[email protected]>…
lib/string.c +11
-0+#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - Like memcmp but a non-zero return code simply indicates a non-match. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count);
This is confusing where the comment says "like memcmp but .." and then just returns memcmp() unmodified. If anything, I would expect to see
return !!memcmp(cs, ct, conut);
or have a better comment explaining why its the same.
-- Steve
Quoted 4 lines
lib/string.c +4
-0+} +EXPORT_SYMBOL (bcmp); +#endif +
Re: [PATCH v2] lib/string.c: implement a basic bcmp
Quoted 19 lines · Steven Rostedt
lib/string.c __visible int memcmp(const void *cs, const void *ct, size_t count) · line 879
Quoted 11 lines · On Wed, 13 Mar 2019 11:17:15 -0700 Nick Desaulniers <[email protected]>…
lib/string.c +11
-0+#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - Like memcmp but a non-zero return code simply indicates a non-match. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count);This is confusing where the comment says "like memcmp but .." and then just returns
memcmp()unmodified. If anything, I would expect to see
Quoted 1 line
return !!memcmp(cs, ct, conut);
That's more work than strictly needed. memcmp already provides the semantics of bcmp. memcmp just provides more meaning to the signedness of the return code, whereas bcmp does not.
Quoted 2 lines
or have a better comment explaining why its the same.
I could add something about "the signedness of the return code not providing any meaning." What would you like to see in such a comment?
Signature · 2 lines
Thanks, ~Nick Desaulniers
Re: [PATCH v2] lib/string.c: implement a basic bcmp
Quoted 8 lines · On Wed, 13 Mar 2019 11:51:09 -0700 Nick Desaulniers <[email protected]>…
Quoted 4 lines
This is confusing where the comment says "like memcmp but .." and then just returns
memcmp()unmodified. If anything, I would expect to seereturn !!memcmp(cs, ct, conut);That's more work than strictly needed. memcmp already provides the semantics of bcmp. memcmp just provides more meaning to the signedness of the return code, whereas bcmp does not.
I figured you would say as much ;-)
Quoted 6 lines
Quoted 3 lines
or have a better comment explaining why its the same.
I could add something about "the signedness of the return code not providing any meaning." What would you like to see in such a comment?
I think it's the wording that bothers me:
+ * bcmp - Like memcmp but a non-zero return code simply indicates a non-match.
What about:
* bcmp - Like memcmp but non-zero only means a non-match
Then in the description say that bcmp() callers must not expect anything more than zero and non-zero, as different implementations only need to return non-zero for non matches. The non-zero has no other meaning like it does in memcmp(). You could add that memcmp() itself is one implementation of bcmp() but not vice versa.
-- Steve
Re: [PATCH v2] lib/string.c: implement a basic bcmp
Quoted 11 lines · Steven Rostedt
Quoted 5 lines · On Wed, 13 Mar 2019 11:51:09 -0700 Nick Desaulniers <[email protected]>…
Quoted 2 lines
or have a better comment explaining why its the same.
I could add something about "the signedness of the return code not providing any meaning." What would you like to see in such a comment?
I think it's the wording that bothers me:
Quoted 8 lines
+ * bcmp - Like memcmp but a non-zero return code simply indicates a non-match.
What about:
* bcmp - Like memcmp but non-zero only means a non-match
Then in the description say that
bcmp()callers must not expect anything more than zero and non-zero,
Yes, but let's completely avoid mentioning memcmp in the summary.
bcmp - return 0 if and only if the buffers have identical contents @a: pointer to first buffer
@b: pointer to second buffer
@len: size of buffers
The sign or magnitude of a non-zero return value has no particular meaning, and architectures may implement their own more efficient bcmp(). So while this particular implementation is a simple (tail) call to memcmp, do not rely on anything but whether the return value is zero or non-zero.
Rasmus
Steven Rostedt
Acked-byRe: [PATCH v2] lib/string.c: implement a basic bcmp
Quoted 7 lines · On Wed, 13 Mar 2019 20:34:11 +0100 Rasmus Villemoes <[email protected]>…
Yes, but let's completely avoid mentioning memcmp in the summary.
bcmp - return 0 if and only if the buffers have identical contents @a: pointer to first buffer
@b: pointer to second buffer
@len: size of buffers
Quoted 5 lines
The sign or magnitude of a non-zero return value has no particular meaning, and architectures may implement their own more efficient
bcmp(). So while this particular implementation is a simple (tail) call to memcmp, do not rely on anything but whether the return value is zero or non-zero.
Thanks!
-- Steve
PATCH v3 1/1 lib/string.c: implement a basic bcmp
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
---
Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration to include/linux/string.h.
* Reword comment above bcmp.
include/linux/string.h | 3 +++ lib/string.c | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
include/linux/string.h +3 -0
@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif
lib/string.c +15 -0
@@ -866,6 +866,21 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @cs: One area of memory. +* @ct: Another area of memory. +* @count: The size of the areas. +*/ +#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory.
Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH v3] lib/string.c: implement a basic bcmp
Quoted 72 lines · Nick Desaulniers
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.Link:
https://github.com/llvm/llvm-project/commit/8e16d73346f8091461319a7dfc4ddd18eedcff13Reported-by Nathan Chancellor <[email protected]>Reported-by Adhemerval Zanella <[email protected]>Suggested-by Arnd Bergmann <[email protected]>Suggested-by James Y Knight <[email protected]>Suggested-by Masahiro Yamada <[email protected]>Suggested-by Nathan Chancellor <[email protected]>Suggested-by Rasmus Villemoes <[email protected]>Signed-off-by Nick Desaulniers <[email protected]>---
Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration toinclude/linux/string.h.
* Reword comment above bcmp.
include/linux/string.h| 3 +++lib/string.c| 15 +++++++++++++++2 files changed, 18 insertions(+)include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif lib/string.c +3
-0@@ -866,6 +866,21 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical
Quoted 4 lines
contents.
+ * @cs: One area of memory.
+ * @ct: Another area of memory.
+ * @count: The size of the areas.
Where's the rest of the comment that I gave my ack to?
-- Steve
Quoted 12 lines
+ */
lib/string.c +8
-0+#undef bcmp +int bcmp (const void *cs,const void *ct,size_t count) +{ +return memcmp (cs, ct, count); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef
__HAVE_ARCH_MEMSCAN
/**
* memscan - Find a character in an area of memory.
Signature · 1 line
Sent from my Android device with K-9 Mail. Please excuse my brevity and top posting.
PATCH v4 1/1 lib/string.c: implement a basic bcmp
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
---
Changes V3 -> V4:
* Include the entirety of Rasmus' sugguestion, as per Steven.
* Change formal parameter identifiers to match the comment. Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration to include/linux/string.h.
* Reword comment above bcmp.
include/linux/string.h | 3 +++ lib/string.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+)
include/linux/string.h +3 -0
@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif
lib/string.c +20 -0
@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmp +int bcmp (const void *a,const void *b,size_t len) +{ +return memcmp (a, b, len); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory.
Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH v4] lib/string.c: implement a basic bcmp
Quoted 19 lines · Nick Desaulniers
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
Quoted 14 lines
Reported-by Nathan Chancellor <[email protected]>Reported-by Adhemerval Zanella <[email protected]>Suggested-by Arnd Bergmann <[email protected]>Suggested-by James Y Knight <[email protected]>Suggested-by Masahiro Yamada <[email protected]>Suggested-by Nathan Chancellor <[email protected]>Suggested-by Rasmus Villemoes <[email protected]>Signed-off-by Nick Desaulniers <[email protected]>
Thanks for fixing this better than I did (or tried to)!
Quoted 63 lines
---
Changes V3 -> V4:
* Include the entirety of Rasmus' sugguestion, as per Steven.
* Change formal parameter identifiers to match the comment. Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration toinclude/linux/string.h.
* Reword comment above bcmp.include/linux/string.h | 3 +++ lib/string.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+)include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif lib/string.c +20
-0@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmp +int bcmp (const void *a,const void *b,size_t len) +{ +return memcmp (a, b, len); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory. Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersQuoted 20 lines · Nick Desaulniers
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
Quoted 14 lines
Reported-by Nathan Chancellor <[email protected]>Reported-by Adhemerval Zanella <[email protected]>Suggested-by Arnd Bergmann <[email protected]>Suggested-by James Y Knight <[email protected]>Suggested-by Masahiro Yamada <[email protected]>Suggested-by Nathan Chancellor <[email protected]>Suggested-by Rasmus Villemoes <[email protected]>Signed-off-by Nick Desaulniers <[email protected]>
Quoted 63 lines
---
Changes V3 -> V4:
* Include the entirety of Rasmus' sugguestion, as per Steven.
* Change formal parameter identifiers to match the comment. Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration toinclude/linux/string.h.
* Reword comment above bcmp.include/linux/string.h | 3 +++ lib/string.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+)include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif lib/string.c +20
-1@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmp +int bcmp (const void *a,const void *b,size_t len) +{ +return memcmp (a, b, len); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory. -- 2.21.0.360.g471c308f928-goog
Signature · 2 lines
Best Regards Masahiro Yamada
Re: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersQuoted 11 lines · Nick Desaulniers
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Quoted 7 lines
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
Thanks!
Quoted 78 lines
Reported-by Nathan Chancellor <[email protected]>Reported-by Adhemerval Zanella <[email protected]>Suggested-by Arnd Bergmann <[email protected]>Suggested-by James Y Knight <[email protected]>Suggested-by Masahiro Yamada <[email protected]>Suggested-by Nathan Chancellor <[email protected]>Suggested-by Rasmus Villemoes <[email protected]>Signed-off-by Nick Desaulniers <[email protected]>---
Changes V3 -> V4:
* Include the entirety of Rasmus' sugguestion, as per Steven.
* Change formal parameter identifiers to match the comment. Changes V2 -> V3:
* Adjust comment as per Steven to Rasmus' sugguestion.
* Pick up Steven's Ack.
Changes V1 -> V2:
* Add declaration toinclude/linux/string.h.
* Reword comment above bcmp.include/linux/string.h | 3 +++ lib/string.c | 20 ++++++++++++++++++++ 2 files changed, 23 insertions(+)include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif #ifndef __HAVE_ARCH_MEMCHRextern void *memchr (const void *,int ,__kernel_size_t );#endif lib/string.c +20
-0@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmp +int bcmp (const void *a,const void *b,size_t len) +{ +return memcmp (a, b, len); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory. Signature · 1 line
2.21.0.360.g471c308f928-goog
Signature · 2 lines
With Best Regards, Andy Shevchenko
RE: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersFrom: Nick Desaulniers
Quoted 1 line
Sent: 13 March 2019 21:14
...
include/linux/string.h extern void * memscan(void *,int,__kernel_size_t); · line 155
Quoted 11 lines
include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif
Shouldn't that prototype always be present?
Any architecture specific implementation better have the same definition. This is particularly true here since the compiler is going to assume the default calling convention.
The only time you wouldn't want it is when the architecture specific implementation is inline asm.
If that were an option the default implementation would need to be excluded using a different #define.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Re: [PATCH v4] lib/string.c: implement a basic bcmp
Quoted 16 lines · David Laight
From: Nick Desaulniers
Quoted 1 line
Sent: 13 March 2019 21:14
...
include/linux/string.h extern void * memscan(void *,int,__kernel_size_t); · line 155
Quoted 11 lines
include/linux/string.h +3
-0@@ -150,6 +150,9 @@ extern void * memscan(void *,int,__kernel_size_t);#ifndef __HAVE_ARCH_MEMCMPextern int memcmp (const void *,const void *,__kernel_size_t );#endif +#ifndef __HAVE_ARCH_BCMP +extern int bcmp (const void *,const void *,__kernel_size_t ); +#endif Shouldn't that prototype always be present?
Yes and no. The problem is that asm/string.h may decide to implement bcmp (or memcpy, memset, strcpy, ...) as a macro, which would break rather badly when used to declare the function. And we can't undef the macro temporarily. So I think the convention is that asm/string.h provides the prototype before it #defines the macro, see e.g. arch/x86/include/asm/string_32.h which has a #define of memcpy.
There is a fix for the "may be defined as a function-like macro", which is
extern int (bcmp)(const void *,const void *,__kernel_size_t);
I'd like to see that used rather than the ad hoc convention, but it is of course somewhat unconventional C.
Rasmus
Andrew Morton
maintainerRe: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersQuoted 11 lines · On Wed, 13 Mar 2019 14:13:31 -0700 Nick Desaulniers <[email protected]>…
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Quoted 7 lines
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
I guess we should backport this into -stable so that older kernels can be built with newer Clang.
Quoted 11 lines
...
lib/string.c +3
-0@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif +#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents.
lib/string.c __visible int memcmp(const void *cs, const void *ct, size_t count) · line 881
Quoted 10 lines
lib/string.c +10
-0+* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmp
What is the undef for?
Quoted 12 lines
lib/string.c +7
-0+int bcmp (const void *a,const void *b,size_t len) +{ +return memcmp (a, b, len); +} +EXPORT_SYMBOL (bcmp); +#endif +#ifndef __HAVE_ARCH_MEMSCAN/** * memscan - Find a character in an area of memory. Signature · 1 line
2.21.0.360.g471c308f928-goog
Re: [PATCH v4] lib/string.c: implement a basic bcmp
Quoted 22 lines · Andrew Morton
Quoted 11 lines · On Wed, 13 Mar 2019 14:13:31 -0700 Nick Desaulniers <[email protected]>…
A recent optimization in Clang (r355672) lowers comparisons of the return value of memcmp against zero to comparisons of the return value of bcmp against zero. This helps some platforms that implement bcmp more efficiently than memcmp. glibc simply aliases bcmp to memcmp, but an optimized implementation is in the works.
This results in linkage failures for all targets with Clang due to the undefined symbol. For now, just implement bcmp as a tailcail to memcmp to unbreak the build. This routine can be further optimized in the future.
Quoted 7 lines
Other ideas discussed:
* A weak alias was discussed, but breaks for architectures that define their own implementations of memcmp since aliases to declarations are not permitted (only definitions). Arch-specific memcmp implementations typically declare memcmp in C headers, but implement them in assembly.
* -ffreestanding also is used sporadically throughout the kernel.
* -fno-builtin-bcmp doesn't work when doing LTO.
Quoted 2 lines
I guess we should backport this into -stable so that older kernels can be built with newer Clang.
Ah, you're right. I always forget. Is it too late to add
to the patch in your tree?
Quoted 9 lines
Quoted 9 lines
...
lib/string.c +0
-0@@ -866,6 +866,26 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)EXPORT_SYMBOL (memcmp);#endif
Quoted 15 lines
lib/string.c __visible int memcmp(const void *cs, const void *ct, size_t count) · line 881
Quoted 13 lines
lib/string.c +13
-0+#ifndef __HAVE_ARCH_BCMP +/** +* bcmp - returns 0 if and only if the buffers have identical contents. +* @a: pointer to first buffer. +* @b: pointer to second buffer. +* @len: size of buffers. +* +* The sign or magnitude of a non-zero return value has no particular +* meaning, and architectures may implement their own more efficient bcmp(). So +* while this particular implementation is a simple (tail) call to memcmp, do +* not rely on anything but whether the return value is zero or non-zero. +*/ +#undef bcmpWhat is the undef for?
Used the same convention as memcpy. Looking at the rest of the translation unit, I see that there's a mix of functions that do or do not undef their symbol. Rasmus pointed out that memcpy is implemented as a macro for x86 (arch/x86/include/asm/string_32.h). But looking closer now, I suspect it's not needed (anyone declaring memcmp as a macro should be setting __HAVE_ARCH_MEMCMP).
Shall I send you a cleanup removing the undefs for bcmp, memcmp, strcat, strcpy, and strcmp? Of those, I only see memcmp being #defined in arch/m68k/include/asm/string.h, arch/x86/boot/string.h, and arch/x86/include/asm/string_32.h.
Further, I can drop some of the __GNUC__ < 4 code in arch/x86/include/asm/string_32.h. (grepping for __GNUC__, looks like there's a fair amount of code that can be cleaned up). We should probably check it since Clang lies about being GCC 4.2 compatible, which will surely break in horrific ways at some point.
Signature · 2 lines
Thanks, ~Nick Desaulniers
Re: [PATCH v4] lib/string.c: implement a basic bcmp
Quoted 10 lines · Nick Desaulniers
Quoted 2 lines · Andrew Morton
I guess we should backport this into -stable so that older kernels can be built with newer Clang.
Ah, you're right. I always forget. Is it too late to add
to the patch in your tree?
Just noticed now. Thank you for adding it!
Signature · 2 lines
Thanks, ~Nick Desaulniers
Andrew Morton
maintainerRe: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersQuoted 10 lines · On Thu, 21 Mar 2019 10:02:37 -0700 Nick Desaulniers <[email protected]>…
Shall I send you a cleanup removing the undefs for bcmp, memcmp, strcat, strcpy, and strcmp? Of those, I only see memcmp being
#definedinarch/m68k/include/asm/string.h,arch/x86/boot/string.h, andarch/x86/include/asm/string_32.h.Further, I can drop some of the
__GNUC__< 4 code inarch/x86/include/asm/string_32.h. (grepping for__GNUC__, looks like there's a fair amount of code that can be cleaned up). We should probably check it since Clang lies about being GCC 4.2 compatible, which will surely break in horrific ways at some point.\
All sounds good. Some time, when convenient, thanks.
Re: [PATCH v4] lib/string.c: implement a basic bcmp
In reply to Nick DesaulniersQuoted 5 lines · Nick Desaulniers
Quoted 1 line · Andrew Morton
Further, I can drop some of the
__GNUC__< 4 code inarch/x86/include/asm/string_32.h.
Already on its way to Linus:
Re: [PATCH v4] lib/string.c: implement a basic bcmp
Quoted 5 lines · Rasmus Villemoes
Quoted 3 lines · Nick Desaulniers
Quoted 1 line · Andrew Morton
Quoted 9 lines
Quoted 2 lines
Further, I can drop some of the
__GNUC__< 4 code inarch/x86/include/asm/string_32.h.Already on its way to Linus:
Upstream:
"x86/asm: Remove dead __GNUC__ conditionals"
https://git.kernel.org/linus/88ca66d8540ca26119b1428cddb96b37925bdf01
"x86/asm: Remove unused __constant_c_x_memset() macro and inlines"
https://git.kernel.org/linus/2e905c7abdcd5ff09b9df33d25eb7148c85bed2a
- Sedat -
Quoted 28 lines · Nick Desaulniers' via Clang Built Linux
Quoted 28 lines
lib/string.c +9
-1@@ -845,7 +845,13 @@ void *memmove(void *dest, const void *src, size_t count)EXPORT_SYMBOL (memmove);#endif -#ifndef __HAVE_ARCH_MEMCMP +#ifdef __HAVE_ARCH_MEMCMP +int bcmp (const void *cs,const void *ct,size_t n) +{ +return memcmp (cs, ct, n); +} +EXPORT_SYMBOL (bcmp); +#else /** * memcmp - Compare two areas of memory * @cs: One area of memory @@ -864,6 +870,8 @@ __visible int memcmp(const void *cs, const void *ct, size_t count)return res; }EXPORT_SYMBOL (memcmp); +__weak __alias(memcmp) typeof(memcmp) bcmp; +EXPORT_SYMBOL(bcmp);#endif
Quoted 4 lines
Quoted 1 line
#ifndef
__HAVE_ARCH_MEMSCANAlternatively, just not worrying about
__aliasmakes this simpler and seems to work (need to add comments, thoughts?):
Either way seems fine to me. If we don't plan to provide an optimized version, I'd go with the simpler definition rather than the alias.
Arnd
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 34 lines · Sasha Levin
Hi,
[This is an automated email]
This commit has been processed because it contains a -stable tag. The stable tag indicates that it's relevant for the following trees: all
The bot has tested the following trees: v5.0.3, v4.19.30, v4.14.107, v4.9.164, v4.4.176, v3.18.136.
v5.0.3: Build OK!
v4.19.30: Build OK!
v4.14.107: Build OK!
v4.9.164: Build OK!
v4.4.176: Failed to apply! Possible dependencies:
238bcbc4e07f("kbuild: consolidate Clang compiler flags")dbe27a002ef8("kbuild: add -no-integrated-as Clang option unconditionally")v3.18.136: Failed to apply! Possible dependencies:
238bcbc4e07f("kbuild: consolidate Clang compiler flags")
35288e30ebca("Kbuild: fix file name in comment about extra gcc checks")5631d9c42985("kbuild: Fix clang detection")
665d92e38f65("kbuild: do not add $(call ...) to invoke cc-version or cc-fullversion")785f11aa595b("kbuild: Add better clang cross build support")92d6cf2dab83("powerpc: Don't use -mno-strict-align on clang")a37c45cd82e6("kbuild: clang: add -no-integrated-as to KBUILD_[AC]FLAGS")ae6b289a3789("kbuild: SetKBUILD_CFLAGSbefore incl. archMakefile")bb3f38c3c5b7("kbuild: clang: fix build failures with sparse check")bfb38988c51e("kbuild: clang: Disable 'address-of-packed-member' warning")dd33c03b18b3("kbuild: fix cc-ifversion macro")
e79c8385c878("powerpc: Don't do gcc version checks if we're building with clang")ee4eb20dbce9("Makefile: Fix detection of clang when cross-compiling")ef8c4ed9db80("kbuild: allow to use GCC toolchain not in Clang search path")
Quoted 5 lines
How should we proceed with this patch?
--
Thanks,
Sasha
Hi Sasha,
This patch will not be picked up, Nick's patch is a much better fix, which should apply cleanly to all stable branches after it makes it into mainline.
https://lore.kernel.org/lkml/[email protected]/
Thanks for letting us know!
Nathan