[libc] add sprintf

[michaelrj]

Summary

This adds the sprintf entrypoint, as well as unit tests. Currently
sprintf only supports %%, %s, and %c, but the other conversions are on
the way.

[michaelrj]

minor tweaks to various parts of the code

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.stdio.fopen
     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.sprintf
 
     # signal.h entrypoints
     # TODO: Enable signal.h entrypoints after fixing signal.h
     # libc.src.signal.raise
     # libc.src.signal.sigaction
     # libc.src.signal.sigdelset
     # libc.src.signal.sigaddset
     # libc.src.signal.sigemptyset

libc/spec/stdc.td

HeaderSpec StdIO = HeaderSpec<
           FunctionSpec<
               "fwrite",
               RetValSpec<SizeTType>,
               [ArgSpec<ConstVoidRestrictedPtr>,
                ArgSpec<SizeTType>,
                ArgSpec<SizeTType>,
                ArgSpec<FILERestrictedPtr>]
           >,
+          FunctionSpec<
+              "sprintf",
+              RetValSpec<IntType>,
+              [ArgSpec<CharRestrictedPtr>,
+               ArgSpec<ConstCharRestrictedPtr>,
+               ArgSpec<VarArgType>]
+          >,
       ]
   >;
 
   HeaderSpec StdLib = HeaderSpec<
       "stdlib.h",
       [], // Macros
       [
           DivTType,

libc/src/stdio/CMakeLists.txt

add_entrypoint_object(
   SRCS
     fopencookie.cpp
   HDRS
     fopencookie.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
 )
+
+
+add_entrypoint_object(
+  sprintf
+  SRCS
+    sprintf.cpp
+  HDRS
+    sprintf.h
+  DEPENDS
+    libc.include.stdio
+    libc.src.stdio.printf_core.printf_main
+    libc.src.stdio.printf_core.string_writer
+    libc.src.stdio.printf_core.writer
+)

libc/src/stdio/printf_core/CMakeLists.txt

HDRS
     converter.h
     converter_atlas.h
     string_converter.h
     char_converter.h
   DEPENDS
     .writer
     .core_structs
 )
+
+
+add_header_library(
+  printf_main
+  HDRS
+    printf_main.h
+  DEPENDS
+    .parser
+    .converter
+    .writer
+    .core_structs
+    libc.src.__support.arg_list
+)

libc/src/stdio/printf_core/char_converter.h

 //===-- String Converter for printf -----------------------------*- 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/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
-void convert_char(Writer *writer, FormatSection to_conv) {
+void convert_char(Writer *writer, const FormatSection &to_conv) {
   char c = to_conv.conv_val_raw;
 
   if (to_conv.min_width > 1) {
     if ((to_conv.flags & FormatFlags::LEFT_JUSTIFIED) ==
         FormatFlags::LEFT_JUSTIFIED) {
       writer->write(&c, 1);
       writer->write_chars(' ', to_conv.min_width - 1);
     } else {

libc/src/stdio/printf_core/converter.h

 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 // convert will call a conversion function to convert the FormatSection into
 // its string representation, and then that will write the result to the
 // writer.
-void convert(Writer *writer, FormatSection to_conv);
+void convert(Writer *writer, const FormatSection &to_conv);
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_H

libc/src/stdio/printf_core/converter.cpp

 #include LLVM_LIBC_PRINTF_CONV_ATLAS
 #endif
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-void convert(Writer *writer, FormatSection to_conv) {
+void convert(Writer *writer, const FormatSection &to_conv) {
   if (!to_conv.has_conv) {
     writer->write(to_conv.raw_string, to_conv.raw_len);
     return;
   }
   switch (to_conv.conv_name) {
   case '%':
     writer->write("%", 1);
     return;

libc/src/stdio/printf_core/printf_main.h

 #include "src/stdio/printf_core/writer.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int printf_main(Writer *writer, const char *__restrict str,
-                internal::ArgList args) {
+                internal::ArgList &args) {
   Parser parser(str, args);
 
   for (FormatSection cur_section = parser.get_next_section();
        cur_section.raw_len > 0; cur_section = parser.get_next_section()) {
     if (cur_section.has_conv)
       convert(writer, cur_section);
     else
       writer->write(cur_section.raw_string, cur_section.raw_len);

libc/src/stdio/printf_core/string_converter.h

 //===-- String Converter for printf -----------------------------*- 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/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
-void convert_string(Writer *writer, FormatSection to_conv) {
+void convert_string(Writer *writer, const FormatSection &to_conv) {
   int string_len = 0;
 
   for (char *cur_str = reinterpret_cast<char *>(to_conv.conv_val_ptr);
        cur_str[string_len]; ++string_len) {
     ;
   }
 
   if (to_conv.precision >= 0 && to_conv.precision < string_len)

libc/src/stdio/sprintf.h

+//===-- Implementation header of sprintf ------------------------*- 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_SPRINTF_H
+#define LLVM_LIBC_SRC_STDIO_SPRINTF_H
+
+namespace __llvm_libc {
+
+int sprintf(char *__restrict buffer, const char *__restrict format, ...);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STDIO_SPRINTF_H

libc/src/stdio/sprintf.cpp

+//===-- Implementation of sprintf -------------------------------*- 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/sprintf.h"
+
+#include "src/__support/arg_list.h"
+#include "src/stdio/printf_core/printf_main.h"
+#include "src/stdio/printf_core/string_writer.h"
+#include "src/stdio/printf_core/writer.h"
+
+#include <stdarg.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, sprintf,
+                   (char *__restrict buffer, const char *__restrict format,
+                    ...)) {
+  va_list vlist;
+  va_start(vlist, format);
+  internal::ArgList args(vlist); // This holder class allows for easier copying
+                                 // and pointer semantics, as well as handing
+                                 // destruction automatically.
+  va_end(vlist);
+  printf_core::StringWriter str_writer(buffer);
+  printf_core::Writer writer(reinterpret_cast<void *>(&str_writer),
+                             printf_core::write_to_string);
+
+  int ret_val = printf_core::printf_main(&writer, format, args);
+  str_writer.terminate();
+  return ret_val;
+}
+
+} // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

DEPENDS
     libc.src.stdio.fopencookie
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.fwrite
   LINK_LIBRARIES
     LibcMemoryHelpers
 )
 
+add_libc_unittest(
+  sprintf_test
+  SUITE
+    libc_stdio_unittests
+  SRCS
+    sprintf_test.cpp
+  DEPENDS
+    libc.src.stdio.sprintf
+)
+
 add_subdirectory(printf_core)
 
 add_subdirectory(testdata)

libc/test/src/stdio/printf_core/parser_test.cpp

TEST(LlvmLibcPrintfParserTest, EvalRaw) {
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected;
   expected.has_conv = false;
   expected.raw_len = 4;
   expected.raw_string = str;
 
   ASSERT_FORMAT_EQ(expected, format_arr[0]);
+  // TODO: add checks that the format_arr after the last one has length 0
 }
 
 TEST(LlvmLibcPrintfParserTest, EvalSimple) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "test %% test";
   evaluate(format_arr, str);
 
   __llvm_libc::printf_core::FormatSection expected0, expected1, expected2;

libc/test/src/stdio/sprintf_test.cpp

+//===-- Unittests for sprintf ---------------------------------------------===//
+//
+// 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/sprintf.h"
+
+#include "utils/UnitTest/Test.h"
+
+TEST(LlvmLibcSPrintfTest, SimpleNoConv) {
+  char buff[64];
+  int written;
+
+  written = __llvm_libc::sprintf(buff, "A simple string with no conversions.");
+  EXPECT_EQ(written, 36);
+  ASSERT_STREQ(buff, "A simple string with no conversions.");
+}
+
+TEST(LlvmLibcSPrintfTest, PercentConv) {
+  char buff[64];
+  int written;
+
+  written = __llvm_libc::sprintf(buff, "%%");
+  EXPECT_EQ(written, 1);
+  ASSERT_STREQ(buff, "%");
+
+  written = __llvm_libc::sprintf(buff, "abc %% def");
+  EXPECT_EQ(written, 9);
+  ASSERT_STREQ(buff, "abc % def");
+
+  written = __llvm_libc::sprintf(buff, "%%%%%%");
+  EXPECT_EQ(written, 3);
+  ASSERT_STREQ(buff, "%%%");
+}
+
+TEST(LlvmLibcSPrintfTest, CharConv) {
+  char buff[64];
+  int written;
+
+  written = __llvm_libc::sprintf(buff, "%c", 'a');
+  EXPECT_EQ(written, 1);
+  ASSERT_STREQ(buff, "a");
+
+  written = __llvm_libc::sprintf(buff, "%3c %-3c", '1', '2');
+  EXPECT_EQ(written, 7);
+  ASSERT_STREQ(buff, "  1 2  ");
+
+  written = __llvm_libc::sprintf(buff, "%*c", 2, '3');
+  EXPECT_EQ(written, 2);
+  ASSERT_STREQ(buff, " 3");
+}
+
+TEST(LlvmLibcSPrintfTest, StringConv) {
+  char buff[64];
+  int written;
+
+  written = __llvm_libc::sprintf(buff, "%s", "abcDEF123");
+  EXPECT_EQ(written, 9);
+  ASSERT_STREQ(buff, "abcDEF123");
+
+  written = __llvm_libc::sprintf(buff, "%10s %-10s", "centered", "title");
+  EXPECT_EQ(written, 21);
+  ASSERT_STREQ(buff, "  centered title     ");
+
+  written = __llvm_libc::sprintf(buff, "%-5.4s%-4.4s", "words can describe",
+                                 "soups most delicious");
+  EXPECT_EQ(written, 9);
+  ASSERT_STREQ(buff, "word soup");
+
+  written = __llvm_libc::sprintf(buff, "%*s %.*s %*.*s", 10, "beginning", 2,
+                                 "isn't", 12, 10, "important. Ever.");
+  EXPECT_EQ(written, 26);
+  ASSERT_STREQ(buff, " beginning is   important.");
+}
+
+#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+TEST(LlvmLibcSPrintfTest, IndexModeParsing) {
+  char buff[64];
+  int written;
+
+  written = __llvm_libc::sprintf(buff, "%1$s", "abcDEF123");
+  EXPECT_EQ(written, 9);
+  ASSERT_STREQ(buff, "abcDEF123");
+
+  written = __llvm_libc::sprintf(buff, "%1$s %%", "abcDEF123");
+  EXPECT_EQ(written, 11);
+  ASSERT_STREQ(buff, "abcDEF123 %");
+
+  written =
+      __llvm_libc::sprintf(buff, "%3$s %1$s %2$s", "is", "hard", "ordering");
+  EXPECT_EQ(written, 16);
+  ASSERT_STREQ(buff, "ordering is hard");
+
+  written = __llvm_libc::sprintf(
+      buff, "%10$s %9$s %8$c %7$s %6$s, %6$s %5$s %4$-*1$s %3$.*11$s %2$s. %%",
+      6, "pain", "alphabetical", "such", "is", "this", "do", 'u', "would",
+      "why", 1);
+  EXPECT_EQ(written, 45);
+  ASSERT_STREQ(buff, "why would u do this, this is such   a pain. %");
+}
+#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE