[libc] add sprintf size comparison

[michaelrj]

Summary

To accurately measure the size of sprintf in a finished binary, the
easiest method is to simply build a binary with and without sprintf.
This patch adds an integration test that can be built with and without
sprintf, as well as targets to build it.

[sivachandra]

Good to go after absorbing https://reviews.llvm.org/D131752

libc/test/integration/src/stdio/CMakeLists.txt

4

Add a comment here saying that these are really not tests for testing sake but just a way to produce hermetic binaries to be used to compare binary sizes.

[tschuett]

remarks can tell you the number of instructions per function and stack sizes:

https://llvm.org/docs/Remarks.html

[michaelrj]

Remarks seems like a useful tool for future optimization, but here I'm trying to measure not just how many instructions and stack spaces the function takes up. I'm looking to evaluate the number of bytes adding sprintf will add to a file, including things like rodata and other overhead, and it doesn't look like remarks has a way to measure that easily.

[michaelrj]

rebase onto new memory function inclusion method

libc/cmake/modules/LLVMLibCTestRules.cmake

 #     <target name>
 #     SUITE <the suite to which the test should belong>
 #     SRCS <src1.cpp> [src2.cpp ...]
 #     HDRS [hdr1.cpp ...]
 #     LOADER <fully qualified loader target name>
 #     DEPENDS <list of entrypoint or other object targets>
 #     ARGS <list of command line arguments to be passed to the test>
 #     ENV <list of environment variables to set before running the test>
+#     COMPILE_OPTIONS <list of special compile options for this target>
 #   )
 #
 # The loader target should provide a property named LOADER_OBJECT which is
 # the full path to the object file produces when the loader is built.
 #
 # The DEPENDS list can be empty. If not empty, it should be a list of
 # targets added with add_entrypoint_object or add_object_library.
 function(add_integration_test test_name)
   get_fq_target_name(${test_name} fq_target_name)
   if(NOT (${LIBC_TARGET_OS} STREQUAL "linux"))
     message(STATUS "Skipping ${fq_target_name} as it is not available on ${LIBC_TARGET_OS}.")
     return()
   endif()
   cmake_parse_arguments(
     "INTEGRATION_TEST"
     "" # No optional arguments
     "SUITE;LOADER" # Single value arguments
-    "SRCS;HDRS;DEPENDS;ARGS;ENV" # Multi-value arguments
+    "SRCS;HDRS;DEPENDS;ARGS;ENV;COMPILE_OPTIONS" # Multi-value arguments
     ${ARGN}
   )
 
   if(NOT INTEGRATION_TEST_SUITE)
     message(FATAL_ERROR "SUITE not specified for ${fq_target_name}")
   endif()
   if(NOT INTEGRATION_TEST_LOADER)
     message(FATAL_ERROR "The LOADER to link to the integration test is missing.")
set_target_properties(${fq_target_name}
       PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
       ${LIBC_BUILD_DIR}/include
   )
-  target_compile_options(${fq_target_name} PRIVATE -ffreestanding)
+  target_compile_options(${fq_target_name} PRIVATE -ffreestanding ${INTEGRATION_TEST_COMPILE_OPTIONS})
   # We set a number of link options to prevent picking up system libc binaries.
   # Also, we restrict the integration tests to fully static executables. The
   # rtlib is set to compiler-rt to make the compiler drivers pick up the compiler
   # runtime binaries using full paths. Otherwise, files like crtbegin.o are passed
   # as is (and not as paths like /usr/lib/.../crtbegin.o).
   target_link_options(${fq_target_name} PRIVATE --sysroot=${sysroot} -static -stdlib=libc++ --rtlib=compiler-rt)
   add_dependencies(${fq_target_name}
                    ${fq_target_name}.__copy_loader__

libc/test/integration/src/CMakeLists.txt

 add_subdirectory(__support)
 add_subdirectory(pthread)
+add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(threads)

libc/test/integration/src/stdio/CMakeLists.txt

+add_custom_target(stdio-integration-tests)
+add_dependencies(libc-integration-tests stdio-integration-tests)
+
+add_integration_test(
+  sprintf_size_test
+  SUITE
+    stdio-integration-tests
+  SRCS
+    sprintf_size_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.src.stdio.sprintf
+    libc.src.string.memcpy
+    libc.src.string.memset
+  ARGS
+    "%s %c %d"
+    "First arg"
+    "a"
+    "0"
+)
+
+add_integration_test(
+  sprintf_size_test_no_sprintf
+  SUITE
+    stdio-integration-tests
+  SRCS
+    sprintf_size_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.src.string.memcpy
+    libc.src.string.memset
+  ARGS
+    "%s %c %d"
+    "First arg"
+    "a"
+    "0"
+  COMPILE_OPTIONS
+    -DINTEGRATION_DISABLE_PRINTF
+)
+

libc/test/integration/src/stdio/sprintf_size_test.cpp

+//===-- Unittests for getenv ----------------------------------------------===//
+//
+// 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 <stddef.h>
+
+#ifndef INTEGRATION_DISABLE_PRINTF
+#include "src/stdio/sprintf.h"
+#endif
+
+#include "src/string/memcpy.h"
+#include "src/string/memset.h"
+
+#include "utils/IntegrationTest/test.h"
+
+// These aliases are used when the compiler sees a non-trivial struct being
+// copied or initialized. In those cases it will emit a call to memcpy or
+// memset, and then error if they aren't available. Since this is compiled with
+// -ffreestanding the system memory functions aren't available, so we have to
+// provide them explicitly.
+extern "C" void *memcpy(void *__restrict dst, const void *__restrict src,
+                        size_t size) {
+  return __llvm_libc::memcpy(dst, src, size);
+}
+extern "C" void *memset(void *ptr, int value, size_t count) {
+  return __llvm_libc::memset(ptr, value, count);
+}
+
+static bool my_streq(const char *lhs, const char *rhs) {
+  if (lhs == rhs)
+    return true;
+  if (((lhs == static_cast<char *>(nullptr)) &&
+       (rhs != static_cast<char *>(nullptr))) ||
+      ((lhs != static_cast<char *>(nullptr)) &&
+       (rhs == static_cast<char *>(nullptr)))) {
+    return false;
+  }
+  const char *l, *r;
+  for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
+    if (*l != *r)
+      return false;
+
+  return *l == '\0' && *r == '\0';
+}
+
+static int my_strlen(const char *str) {
+  const char *other = str;
+  while (*other)
+    ++other;
+  return static_cast<int>(other - str);
+}
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  ASSERT_EQ(argc, 5);
+  ASSERT_TRUE(my_streq(argv[1], "%s %c %d"));
+  ASSERT_EQ(my_strlen(argv[1]), 8);
+  ASSERT_TRUE(my_streq(argv[2], "First arg"));
+  ASSERT_EQ(my_strlen(argv[2]), 9);
+  ASSERT_TRUE(my_streq(argv[3], "a"));
+  ASSERT_EQ(my_strlen(argv[3]), 1);
+  ASSERT_TRUE(my_streq(argv[4], "0"));
+  ASSERT_EQ(my_strlen(argv[4]), 1);
+
+#ifndef INTEGRATION_DISABLE_PRINTF
+  char buf[100];
+  ASSERT_EQ(__llvm_libc::sprintf(buf, argv[1], argv[2], argv[3][0], argv[4][0]),
+            14);
+  ASSERT_TRUE(my_streq(buf, "First arg a 48"));
+#endif
+
+  return 0;
+}