025.undefined_reference_to_'stpcpy'.patch

commit cec73f07755267deea6c2bfcd9860035b700ed7b
Author: Nick Desaulniers <ndesaulniers@google.com>
Date:   Tue Aug 25 06:58:36 2020 -0700

    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.
    
    Cc: stable@vger.kernel.org
    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
    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>
    Reported-by: Sami Tolvanen <samitolvanen@google.com>
    Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
    Signed-off-by: Danny Lin <danny@kdrag0n.dev>

diff --git a/lib/string.c b/lib/string.c
index 33befc6ba3fa..38450d042444 100644
--- a/lib/string.c
+++ b/lib/string.c
@@ -236,6 +236,30 @@ ssize_t strscpy(char *dest, const char *src, size_t count)
 EXPORT_SYMBOL(strscpy);
 #endif
 
+/**
+ * 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