[libc] Add v variants of printf functions

[michaelrj]

Summary

The v variants of the printf functions take their variadic arguments as
a va_list instead of as individual arguments. They are otherwise
identical to the corresponding printf variants. This patch adds them
(vprintf, vfprintf, vsprintf, and vsnprintf) as well as tests.

[phosek]

libc/test/src/stdio/vsprintf_test.cpp

26–28

This doesn't seem to be used anywhere.

[michaelrj]

rebase and add bazel support

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.realloc
     libc.src.stdlib.aligned_alloc
     libc.src.stdlib.free
 
     # stdio.h entrypoints
     libc.src.stdio.remove
     libc.src.stdio.sprintf
     libc.src.stdio.snprintf
+    libc.src.stdio.vsprintf
+    libc.src.stdio.vsnprintf
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.madvise
     libc.src.sys.mman.mmap
     libc.src.sys.mman.mprotect
     libc.src.sys.mman.munmap
     libc.src.sys.mman.posix_madvise
 
list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fputs
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fread_unlocked
     libc.src.stdio.fseek
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.fwrite_unlocked
-    libc.src.stdio.fprintf
     libc.src.stdio.getchar
     libc.src.stdio.getchar_unlocked
+    #TODO: Look into if fprintf can be enabled for overlay on aarch64
+    libc.src.stdio.fprintf
     libc.src.stdio.printf
+    libc.src.stdio.vfprintf
+    libc.src.stdio.vprintf
     libc.src.stdio.putc
     libc.src.stdio.putchar
     libc.src.stdio.puts
     libc.src.stdio.stderr
     libc.src.stdio.stdin
     libc.src.stdio.stdout
 
     # stdlib.h entrypoints

libc/config/linux/riscv64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.free
 
     # stdio.h entrypoints
     libc.src.stdio.remove
     libc.src.stdio.sprintf
     libc.src.stdio.snprintf
     libc.src.stdio.fprintf
     libc.src.stdio.printf
+    libc.src.stdio.vsprintf
+    libc.src.stdio.vsnprintf
+    libc.src.stdio.vfprintf
+    libc.src.stdio.vprintf
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.madvise
     libc.src.sys.mman.mmap
     libc.src.sys.mman.mprotect
     libc.src.sys.mman.munmap
     libc.src.sys.mman.posix_madvise
 

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.free
 
     # stdio.h entrypoints
     libc.src.stdio.remove
     libc.src.stdio.sprintf
     libc.src.stdio.snprintf
     libc.src.stdio.fprintf
     libc.src.stdio.printf
+    libc.src.stdio.vsprintf
+    libc.src.stdio.vsnprintf
+    libc.src.stdio.vfprintf
+    libc.src.stdio.vprintf
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.madvise
     libc.src.sys.mman.mmap
     libc.src.sys.mman.mprotect
     libc.src.sys.mman.munmap
     libc.src.sys.mman.posix_madvise
 

libc/include/stdio.h.def

 //===-- C standard library header stdio.h ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_STDIO_H
 #define LLVM_LIBC_STDIO_H
 
 #include <__llvm-libc-common.h>
 #include <llvm-libc-macros/file-seek-macros.h>
 #include <llvm-libc-macros/stdio-macros.h>
 
+#include <stdarg.h>
+
 %%public_api()
 
 #endif // LLVM_LIBC_STDIO_H

libc/spec/spec.td

 }
 
 class RestrictedPtrType<Type type> : Type {
   Type PointeeType = type;
 }
 
 // Builtin types.
 def VarArgType : NamedType<"...">;
+def VaListType : NamedType<"va_list">;
 def VoidType : NamedType<"void">;
 def IntType : NamedType<"int">;
 def UnsignedIntType : NamedType<"unsigned int">;
 def LongType : NamedType<"long">;
 def UnsignedLongType : NamedType<"unsigned long">;
 def LongLongType : NamedType<"long long">;
 def UnsignedLongLongType : NamedType<"unsigned long long">;
 def FloatType : NamedType<"float">;

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
           FunctionSpec<
               "fprintf",
               RetValSpec<IntType>,
               [ArgSpec<FILERestrictedPtr>,
                ArgSpec<ConstCharRestrictedPtr>,
                ArgSpec<VarArgType>]
           >,
           FunctionSpec<
+              "vsprintf",
+              RetValSpec<IntType>,
+              [ArgSpec<CharRestrictedPtr>,
+               ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<VaListType>]
+          >,
+          FunctionSpec<
+              "vsnprintf",
+              RetValSpec<IntType>,
+              [ArgSpec<CharRestrictedPtr>,
+               ArgSpec<SizeTType>,
+               ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<VaListType>]
+          >,
+          FunctionSpec<
+              "vprintf",
+              RetValSpec<IntType>,
+              [ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<VaListType>]
+          >,
+          FunctionSpec<
+              "vfprintf",
+              RetValSpec<IntType>,
+              [ArgSpec<FILERestrictedPtr>,
+               ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<VaListType>]
+          >,
+          FunctionSpec<
               "ungetc",
               RetValSpec<IntType>,
               [ArgSpec<IntType>, ArgSpec<FILEPtr>]
           >,
       ],
       [
           ObjectSpec<
               "stdin",

libc/src/stdio/CMakeLists.txt

add_entrypoint_object(
   DEPENDS
     libc.src.__support.arg_list
     libc.src.stdio.printf_core.vfprintf_internal
   COMPILE_OPTIONS
     ${printf_copts}
 )
 
 add_entrypoint_object(
+  vsprintf
+  SRCS
+    vsprintf.cpp
+  HDRS
+    vsprintf.h
+  DEPENDS
+    libc.src.stdio.printf_core.printf_main
+    libc.src.stdio.printf_core.writer
+)
+
+add_entrypoint_object(
+  vsnprintf
+  SRCS
+    vsnprintf.cpp
+  HDRS
+    vsnprintf.h
+  DEPENDS
+    libc.src.stdio.printf_core.printf_main
+    libc.src.stdio.printf_core.writer
+)
+
+add_entrypoint_object(
+  vprintf
+  SRCS
+    vprintf.cpp
+  HDRS
+    vprintf.h
+  DEPENDS
+    ${printf_deps}
+  COMPILE_OPTIONS
+    ${printf_copts}
+)
+
+add_entrypoint_object(
+  vfprintf
+  SRCS
+    vfprintf.cpp
+  HDRS
+    vfprintf.h
+  DEPENDS
+    libc.src.__support.arg_list
+    libc.src.stdio.printf_core.vfprintf_internal
+  COMPILE_OPTIONS
+    ${printf_copts}
+)
+
+add_entrypoint_object(
   ftell
   SRCS
     ftell.cpp
   HDRS
     ftell.h
   DEPENDS
     libc.src.errno.errno
     libc.include.stdio

libc/src/stdio/vfprintf.h

+//===-- Implementation header of vfprintf -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_VFPRINTF_H
+#define LLVM_LIBC_SRC_STDIO_VFPRINTF_H
+
+#include <stdarg.h>
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int vfprintf(::FILE *__restrict stream, const char *__restrict format,
+             va_list vlist);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_VFPRINTF_H

libc/src/stdio/vfprintf.cpp

+//===-- Implementation of vfprintf ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/vfprintf.h"
+
+#include "src/__support/File/file.h"
+#include "src/__support/arg_list.h"
+#include "src/stdio/printf_core/vfprintf_internal.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, vfprintf,
+                   (::FILE *__restrict stream, const char *__restrict format,
+                    va_list vlist)) {
+  internal::ArgList args(vlist); // This holder class allows for easier copying
+                                 // and pointer semantics, as well as handling
+                                 // destruction automatically.
+  int ret_val = printf_core::vfprintf_internal(stream, format, args);
+  return ret_val;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/vprintf.h

+//===-- Implementation header of vprintf ------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_VPRINTF_H
+#define LLVM_LIBC_SRC_STDIO_VPRINTF_H
+
+#include <stdarg.h>
+#include <stdio.h>
+
+namespace __llvm_libc {
+
+int vprintf(const char *__restrict format, va_list vlist);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_VPRINTF_H

libc/src/stdio/vprintf.cpp

+//===-- Implementation of vprintf -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/vprintf.h"
+
+#include "src/__support/File/file.h"
+#include "src/__support/arg_list.h"
+#include "src/stdio/printf_core/vfprintf_internal.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#ifndef LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+#define PRINTF_STDOUT __llvm_libc::stdout
+#else // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+#define PRINTF_STDOUT ::stdout
+#endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, vprintf,
+                   (const char *__restrict format, va_list vlist)) {
+  internal::ArgList args(vlist); // This holder class allows for easier copying
+                                 // and pointer semantics, as well as handling
+                                 // destruction automatically.
+  int ret_val = printf_core::vfprintf_internal(
+      reinterpret_cast<::FILE *>(PRINTF_STDOUT), format, args);
+  return ret_val;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/vsnprintf.h

+//===-- Implementation header of vsnprintf ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_VSNPRINTF_H
+#define LLVM_LIBC_SRC_STDIO_VSNPRINTF_H
+
+#include <stdarg.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+int vsnprintf(char *__restrict buffer, size_t buffsz,
+              const char *__restrict format, va_list vlist);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_VSNPRINTF_H

libc/src/stdio/vsnprintf.cpp

+//===-- Implementation of vsnprintf -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/vsnprintf.h"
+
+#include "src/__support/arg_list.h"
+#include "src/stdio/printf_core/printf_main.h"
+#include "src/stdio/printf_core/writer.h"
+
+#include <stdarg.h>
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, vsnprintf,
+                   (char *__restrict buffer, size_t buffsz,
+                    const char *__restrict format, va_list vlist)) {
+  internal::ArgList args(vlist); // This holder class allows for easier copying
+                                 // and pointer semantics, as well as handling
+                                 // destruction automatically.
+  printf_core::WriteBuffer wb(buffer, (buffsz > 0 ? buffsz - 1 : 0));
+  printf_core::Writer writer(&wb);
+
+  int ret_val = printf_core::printf_main(&writer, format, args);
+  if (buffsz > 0) // if the buffsz is 0 the buffer may be a null pointer.
+    wb.buff[wb.buff_cur] = '\0';
+  return ret_val;
+}
+
+} // namespace __llvm_libc

libc/src/stdio/vsprintf.h

+//===-- Implementation header of vsprintf -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STDIO_VSPRINTF_H
+#define LLVM_LIBC_SRC_STDIO_VSPRINTF_H
+
+#include <stdarg.h>
+
+namespace __llvm_libc {
+
+int vsprintf(char *__restrict buffer, const char *__restrict format,
+             va_list vlist);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_VSPRINTF_H

libc/src/stdio/vsprintf.cpp

+//===-- Implementation of vsprintf ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/stdio/vsprintf.h"
+
+#include "src/__support/CPP/limits.h"
+#include "src/__support/arg_list.h"
+#include "src/stdio/printf_core/printf_main.h"
+#include "src/stdio/printf_core/writer.h"
+
+#include <stdarg.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, vsprintf,
+                   (char *__restrict buffer, const char *__restrict format,
+                    va_list vlist)) {
+  internal::ArgList args(vlist); // This holder class allows for easier copying
+                                 // and pointer semantics, as well as handling
+                                 // destruction automatically.
+
+  printf_core::WriteBuffer wb(buffer, cpp::numeric_limits<size_t>::max());
+  printf_core::Writer writer(&wb);
+
+  int ret_val = printf_core::printf_main(&writer, format, args);
+  wb.buff[wb.buff_cur] = '\0';
+  return ret_val;
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

add_libc_unittest(
   SUITE
     libc_stdio_unittests
   SRCS
     snprintf_test.cpp
   DEPENDS
     libc.src.stdio.snprintf
 )
 
-list(APPEND fprintf_test_deps
-      libc.src.stdio.fprintf
-)
 if(LLVM_LIBC_FULL_BUILD)
 # In fullbuild mode, fprintf's tests use the internal FILE for other functions.
  list(APPEND fprintf_test_deps
       libc.src.stdio.fclose
       libc.src.stdio.ferror
       libc.src.stdio.fopen
       libc.src.stdio.fread
   )
 else()
 # Else in overlay mode they use the system's FILE.
  set(fprintf_test_copts "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE")
 endif()
 
 add_libc_unittest(
   fprintf_test
   SUITE
     libc_stdio_unittests
   SRCS
     fprintf_test.cpp
   DEPENDS
+    libc.src.stdio.fprintf
     ${fprintf_test_deps}
   COMPILE_OPTIONS
     ${fprintf_test_copts}
 )
 
 add_libc_unittest(
   printf_test
   SUITE
     libc_stdio_unittests
   SRCS
     printf_test.cpp
   DEPENDS
     libc.src.stdio.printf
 )
 
+add_fp_unittest(
+  vsprintf_test
+  UNIT_TEST_ONLY
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    vsprintf_test.cpp
+  DEPENDS
+    libc.src.stdio.vsprintf
+)
+
+add_libc_unittest(
+  vsnprintf_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    vsnprintf_test.cpp
+  DEPENDS
+    libc.src.stdio.vsnprintf
+)
+
+add_libc_unittest(
+  vfprintf_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    vfprintf_test.cpp
+  DEPENDS
+    libc.src.stdio.vfprintf
+    ${fprintf_test_deps}
+  COMPILE_OPTIONS
+    ${fprintf_test_copts}
+)
+
+add_libc_unittest(
+  vprintf_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    vprintf_test.cpp
+  DEPENDS
+    libc.src.stdio.vprintf
+)
+
 add_libc_unittest(
   fscanf_test
   SUITE
     libc_stdio_unittests
   SRCS
     fscanf_test.cpp
   DEPENDS
     libc.src.stdio.fscanf

libc/test/src/stdio/vfprintf_test.cpp

+//===-- Unittests for vfprintf --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// These tests are copies of the non-v variants of the printf functions. This is
+// because these functions are identical in every way except for how the varargs
+// are passed.
+
+#ifndef LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+#include "src/stdio/fclose.h"
+#include "src/stdio/ferror.h"
+#include "src/stdio/fopen.h"
+#include "src/stdio/fread.h"
+#endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+
+#include "src/stdio/vfprintf.h"
+
+#include "test/UnitTest/Test.h"
+
+#include <stdio.h>
+
+namespace printf_test {
+#ifndef LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+using __llvm_libc::fclose;
+using __llvm_libc::ferror;
+using __llvm_libc::fopen;
+using __llvm_libc::fread;
+#else  // defined(LIBC_COPT_PRINTF_USE_SYSTEM_FILE)
+using ::fclose;
+using ::ferror;
+using ::fopen;
+using ::fread;
+#endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+} // namespace printf_test
+
+int call_vfprintf(::FILE *__restrict stream, const char *__restrict format,
+                  ...) {
+  va_list vlist;
+  va_start(vlist, format);
+  int ret = __llvm_libc::vfprintf(stream, format, vlist);
+  va_end(vlist);
+  return ret;
+}
+
+TEST(LlvmLibcVFPrintfTest, WriteToFile) {
+  const char *FILENAME = "fprintf_output.test";
+  auto FILE_PATH = libc_make_test_file_path(FILENAME);
+
+  ::FILE *file = printf_test::fopen(FILE_PATH, "w");
+  ASSERT_FALSE(file == nullptr);
+
+  int written;
+
+  constexpr char simple[] = "A simple string with no conversions.\n";
+  written = call_vfprintf(file, simple);
+  EXPECT_EQ(written, 37);
+
+  constexpr char numbers[] = "1234567890\n";
+  written = call_vfprintf(file, "%s", numbers);
+  EXPECT_EQ(written, 11);
+
+  constexpr char format_more[] = "%s and more\n";
+  constexpr char short_numbers[] = "1234";
+  written = call_vfprintf(file, format_more, short_numbers);
+  EXPECT_EQ(written, 14);
+
+  ASSERT_EQ(0, printf_test::fclose(file));
+
+  file = printf_test::fopen(FILE_PATH, "r");
+  ASSERT_FALSE(file == nullptr);
+
+  char data[50];
+  ASSERT_EQ(printf_test::fread(data, 1, sizeof(simple) - 1, file),
+            sizeof(simple) - 1);
+  data[sizeof(simple) - 1] = '\0';
+  ASSERT_STREQ(data, simple);
+  ASSERT_EQ(printf_test::fread(data, 1, sizeof(numbers) - 1, file),
+            sizeof(numbers) - 1);
+  data[sizeof(numbers) - 1] = '\0';
+  ASSERT_STREQ(data, numbers);
+  ASSERT_EQ(printf_test::fread(
+                data, 1, sizeof(format_more) + sizeof(short_numbers) - 4, file),
+            sizeof(format_more) + sizeof(short_numbers) - 4);
+  data[sizeof(format_more) + sizeof(short_numbers) - 4] = '\0';
+  ASSERT_STREQ(data, "1234 and more\n");
+
+  ASSERT_EQ(printf_test::ferror(file), 0);
+
+  written = call_vfprintf(file, "Writing to a read only file should fail.");
+  EXPECT_LT(written, 0);
+
+  ASSERT_EQ(printf_test::fclose(file), 0);
+}

libc/test/src/stdio/vprintf_test.cpp

+//===-- Unittests for vprintf --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// These tests are copies of the non-v variants of the printf functions. This is
+// because these functions are identical in every way except for how the varargs
+// are passed.
+
+#include "src/stdio/vprintf.h"
+
+#include "test/UnitTest/Test.h"
+
+int call_vprintf(const char *__restrict format, ...) {
+  va_list vlist;
+  va_start(vlist, format);
+  int ret = __llvm_libc::vprintf(format, vlist);
+  va_end(vlist);
+  return ret;
+}
+
+TEST(LlvmLibcVPrintfTest, PrintOut) {
+  int written;
+
+  constexpr char simple[] = "A simple string with no conversions.\n";
+  written = call_vprintf(simple);
+  EXPECT_EQ(written, static_cast<int>(sizeof(simple) - 1));
+
+  constexpr char numbers[] = "1234567890\n";
+  written = call_vprintf("%s", numbers);
+  EXPECT_EQ(written, static_cast<int>(sizeof(numbers) - 1));
+
+  constexpr char format_more[] = "%s and more\n";
+  constexpr char short_numbers[] = "1234";
+  written = call_vprintf(format_more, short_numbers);
+  EXPECT_EQ(written,
+            static_cast<int>(sizeof(format_more) + sizeof(short_numbers) - 4));
+}

libc/test/src/stdio/vsnprintf_test.cpp

+//===-- Unittests for snprintf --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// These tests are copies of the non-v variants of the printf functions. This is
+// because these functions are identical in every way except for how the varargs
+// are passed.
+
+#include "src/stdio/vsnprintf.h"
+
+#include "test/UnitTest/Test.h"
+
+int call_vsnprintf(char *__restrict buffer, size_t buffsz,
+                   const char *__restrict format, ...) {
+  va_list vlist;
+  va_start(vlist, format);
+  int ret = __llvm_libc::vsnprintf(buffer, buffsz, format, vlist);
+  va_end(vlist);
+  return ret;
+}
+
+// The sprintf test cases cover testing the shared printf functionality, so
+// these tests will focus on snprintf exclusive features.
+
+TEST(LlvmLibcVSNPrintfTest, CutOff) {
+  char buff[100];
+  int written;
+
+  written = call_vsnprintf(buff, 16, "A simple string with no conversions.");
+  EXPECT_EQ(written, 36);
+  ASSERT_STREQ(buff, "A simple string");
+
+  written = call_vsnprintf(buff, 5, "%s", "1234567890");
+  EXPECT_EQ(written, 10);
+  ASSERT_STREQ(buff, "1234");
+
+  written = call_vsnprintf(buff, 67, "%-101c", 'a');
+  EXPECT_EQ(written, 101);
+  ASSERT_STREQ(buff, "a "
+                     "        " // Each of these is 8 spaces, and there are 8.
+                     "        " // In total there are 65 spaces
+                     "        " // 'a' + 65 spaces + '\0' = 67
+                     "        "
+                     "        "
+                     "        "
+                     "        "
+                     "        ");
+
+  // passing null as the output pointer is allowed as long as buffsz is 0.
+  written = call_vsnprintf(nullptr, 0, "%s and more", "1234567890");
+  EXPECT_EQ(written, 19);
+}
+
+TEST(LlvmLibcVSNPrintfTest, NoCutOff) {
+  char buff[64];
+  int written;
+
+  written = call_vsnprintf(buff, 37, "A simple string with no conversions.");
+  EXPECT_EQ(written, 36);
+  ASSERT_STREQ(buff, "A simple string with no conversions.");
+
+  written = call_vsnprintf(buff, 20, "%s", "1234567890");
+  EXPECT_EQ(written, 10);
+  ASSERT_STREQ(buff, "1234567890");
+}

libc/test/src/stdio/vsprintf_test.cpp

+//===-- Unittests for vsprintf --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// These tests are shortened copies of the non-v variants of the printf
+// functions. This is because these functions are identical in every way except
+// for how the varargs are passed.
+
+#include "src/stdio/vsprintf.h"
+
+#include "test/UnitTest/Test.h"
+
+int call_vsprintf(char *__restrict buffer, const char *__restrict format, ...) {
+  va_list vlist;
+  va_start(vlist, format);
+  int ret = __llvm_libc::vsprintf(buffer, format, vlist);
+  va_end(vlist);
+  return ret;
+}
+
+// Subtract 1 from sizeof(expected_str) to account for the null byte.
+#define ASSERT_STREQ_LEN(actual_written, actual_str, expected_str)             \
+  EXPECT_EQ(actual_written, static_cast<int>(sizeof(expected_str) - 1));       \
+  EXPECT_STREQ(actual_str, expected_str);
+
+TEST(LlvmLibcVSPrintfTest, SimpleNoConv) {
+  char buff[64];
+  int written;
+
+  written = call_vsprintf(buff, "A simple string with no conversions.");
+  EXPECT_EQ(written, 36);
+  ASSERT_STREQ(buff, "A simple string with no conversions.");
+}
+
+TEST(LlvmLibcVSPrintfTest, PercentConv) {
+  char buff[64];
+  int written;
+
+  written = call_vsprintf(buff, "%%");
+  EXPECT_EQ(written, 1);
+  ASSERT_STREQ(buff, "%");
+
+  written = call_vsprintf(buff, "abc %% def");
+  EXPECT_EQ(written, 9);
+  ASSERT_STREQ(buff, "abc % def");
+
+  written = call_vsprintf(buff, "%%%%%%");
+  EXPECT_EQ(written, 3);
+  ASSERT_STREQ(buff, "%%%");
+}
+
+TEST(LlvmLibcVSPrintfTest, CharConv) {
+  char buff[64];
+  int written;
+
+  written = call_vsprintf(buff, "%c", 'a');
+  EXPECT_EQ(written, 1);
+  ASSERT_STREQ(buff, "a");
+
+  written = call_vsprintf(buff, "%3c %-3c", '1', '2');
+  EXPECT_EQ(written, 7);
+  ASSERT_STREQ(buff, "  1 2  ");
+
+  written = call_vsprintf(buff, "%*c", 2, '3');
+  EXPECT_EQ(written, 2);
+  ASSERT_STREQ(buff, " 3");
+}