123 lines
5.2 KiB
Diff
123 lines
5.2 KiB
Diff
From 5934637641c863cc2c1765a0d01c5b6f53ecc4fc Mon Sep 17 00:00:00 2001
|
|
From: Nick Desaulniers <ndesaulniers@google.com>
|
|
Date: Wed, 26 Aug 2020 15:21:29 +1000
|
|
Subject: lib/string.c: implement stpcpy
|
|
|
|
LLVM implemented a recent "libcall optimization" that lowers calls to
|
|
`sprintf(dest, "%s", str)` where the return value is used to `stpcpy(dest,
|
|
str) - dest`. This generally avoids the machinery involved in parsing
|
|
format strings. `stpcpy` is just like `strcpy` except it returns the
|
|
pointer to the new tail of `dest`. This optimization was introduced into
|
|
clang-12.
|
|
|
|
Implement this so that we don't observe linkage failures due to missing
|
|
symbol definitions for `stpcpy`.
|
|
|
|
Similar to last year's fire drill with: commit 5f074f3e192f
|
|
("lib/string.c: implement a basic bcmp")
|
|
|
|
The kernel is somewhere between a "freestanding" environment (no full
|
|
libc) and "hosted" environment (many symbols from libc exist with the same
|
|
type, function signature, and semantics).
|
|
|
|
As H. Peter Anvin notes, there's not really a great way to inform the
|
|
compiler that you're targeting a freestanding environment but would like
|
|
to opt-in to some libcall optimizations (see pr/47280 below), rather than
|
|
opt-out.
|
|
|
|
Arvind notes, -fno-builtin-* behaves slightly differently between GCC and
|
|
Clang, and Clang is missing many __builtin_* definitions, which I consider
|
|
a bug in Clang and am working on fixing.
|
|
|
|
Masahiro summarizes the subtle distinction between compilers justly:
|
|
To prevent transformation from foo() into bar(), there are two ways in
|
|
Clang to do that; -fno-builtin-foo, and -fno-builtin-bar. There is
|
|
only one in GCC; -fno-buitin-foo.
|
|
|
|
(Any difference in that behavior in Clang is likely a bug from a missing
|
|
__builtin_* definition.)
|
|
|
|
Masahiro also notes:
|
|
We want to disable optimization from foo() to bar(),
|
|
but we may still benefit from the optimization from
|
|
foo() into something else. If GCC implements the same transform, we
|
|
would run into a problem because it is not -fno-builtin-bar, but
|
|
-fno-builtin-foo that disables that optimization.
|
|
|
|
In this regard, -fno-builtin-foo would be more future-proof than
|
|
-fno-built-bar, but -fno-builtin-foo is still potentially overkill. We
|
|
may want to prevent calls from foo() being optimized into calls to
|
|
bar(), but we still may want other optimization on calls to foo().
|
|
|
|
It seems that compilers today don't quite provide the fine grain control
|
|
over which libcall optimizations pseudo-freestanding environments would
|
|
prefer.
|
|
|
|
Finally, Kees notes that this interface is unsafe, so we should not
|
|
encourage its use. As such, I've removed the declaration from any header,
|
|
but it still needs to be exported to avoid linkage errors in modules.
|
|
|
|
Link: https://lkml.kernel.org/r/20200825140001.2941001-1-ndesaulniers@google.com
|
|
Link: https://bugs.llvm.org/show_bug.cgi?id=47162
|
|
Link: https://bugs.llvm.org/show_bug.cgi?id=47280
|
|
Link: https://github.com/ClangBuiltLinux/linux/issues/1126
|
|
Link: https://man7.org/linux/man-pages/man3/stpcpy.3.html
|
|
Link: https://pubs.opengroup.org/onlinepubs/9699919799/functions/stpcpy.html
|
|
Link: https://reviews.llvm.org/D85963
|
|
Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
|
|
Reported-by: Sami Tolvanen <samitolvanen@google.com>
|
|
Tested-by: Nathan Chancellor <natechancellor@gmail.com>
|
|
Suggested-by: Andy Lavr <andy.lavr@gmail.com>
|
|
Suggested-by: Arvind Sankar <nivedita@alum.mit.edu>
|
|
Suggested-by: Joe Perches <joe@perches.com>
|
|
Suggested-by: Masahiro Yamada <masahiroy@kernel.org>
|
|
Suggested-by: Rasmus Villemoes <linux@rasmusvillemoes.dk>
|
|
Cc: <stable@vger.kernel.org>
|
|
Cc: Kees Cook <keescook@chromium.org>
|
|
Cc: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
|
|
Cc: Alexandru Ardelean <alexandru.ardelean@analog.com>
|
|
Cc: Yury Norov <yury.norov@gmail.com>
|
|
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
|
|
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
|
|
---
|
|
lib/string.c | 24 ++++++++++++++++++++++++
|
|
1 file changed, 24 insertions(+)
|
|
|
|
diff --git a/lib/string.c b/lib/string.c
|
|
index 6012c385fb314d..6bd0cf0fb009a2 100644
|
|
--- a/lib/string.c
|
|
+++ b/lib/string.c
|
|
@@ -272,6 +272,30 @@ ssize_t strscpy_pad(char *dest, const char *src, size_t count)
|
|
}
|
|
EXPORT_SYMBOL(strscpy_pad);
|
|
|
|
+/**
|
|
+ * stpcpy - copy a string from src to dest returning a pointer to the new end
|
|
+ * of dest, including src's %NUL-terminator. May overrun dest.
|
|
+ * @dest: pointer to end of string being copied into. Must be large enough
|
|
+ * to receive copy.
|
|
+ * @src: pointer to the beginning of string being copied from. Must not overlap
|
|
+ * dest.
|
|
+ *
|
|
+ * stpcpy differs from strcpy in a key way: the return value is the new
|
|
+ * %NUL-terminated character. (for strcpy, the return value is a pointer to
|
|
+ * src. This interface is considered unsafe as it doesn't perform bounds
|
|
+ * checking of the inputs. As such it's not recommended for usage. Instead,
|
|
+ * its definition is provided in case the compiler lowers other libcalls to
|
|
+ * stpcpy.
|
|
+ */
|
|
+char *stpcpy(char *__restrict__ dest, const char *__restrict__ src);
|
|
+char *stpcpy(char *__restrict__ dest, const char *__restrict__ src)
|
|
+{
|
|
+ while ((*dest++ = *src++) != '\0')
|
|
+ /* nothing */;
|
|
+ return --dest;
|
|
+}
|
|
+EXPORT_SYMBOL(stpcpy);
|
|
+
|
|
#ifndef __HAVE_ARCH_STRCAT
|
|
/**
|
|
* strcat - Append one %NUL-terminated string to another
|
|
--
|
|
cgit 1.2.3-korg
|
|
|