[libc][bazel] add file printf targets and support

[michaelrj]

Summary

This patch adds targets for printf and fprintf to the bazel build.
Additionally, it adds support for the build system to specify where
files should be written for testing purposes. This was necessary to
enable the fprintf test under bazel.

[michaelrj]

add DISABLE_INDEX_MODE and DISABLE_WRITE_INT flags, unify the PRINTF_COPTS location, and adjust the libc_function rule to properly handle immutable lists.

[sivachandra]

To avoid calling getenv on all platforms, I suggest doing this:

1. Add a convenience function declaration, say cpp::string make_test_file_path(const char *) in LibcTest.h.
2. Add implementations in cmake.cpp and bazel.cpp for CMake and Bazel restpectively. The one in cmake.cpp would just be a passthrough. The one in bazel.cpp will implement mostly the logic you have added in this patch.
3. In the CMake target for LibcUnitTest add cmake.cpp and in the one for Bazel, add bazel.cpp.

[michaelrj]

rewrite to make the test file path system more generic.

[sivachandra]

libc/test/UnitTest/BazelFilePath.cpp

19

We should ideally avoid depending on global object initialization. Can we call getenv from inside the function below?

libc/test/UnitTest/CmakeFilePath.cpp

20

Do we really need the testdata/ prefix? As in, can we not just create a file in the same directory as the test? It makes this function a simple pass through.

libc/utils/testutils/OwnedString.h

14

Why is this class required?

utils/bazel/llvm-project-overlay/libc/libc_build_rules.bzl

13

These should be defined in libc/BUILD.bazel. Also, they should passed to libc_function as defines = PRINTF_COPTS, which then will be passed to tests which depend on those functions which use those defines.

utils/bazel/llvm-project-overlay/libc/test/libc_test_rules.bzl

17

Unused?

[michaelrj]

address comments and move OwnedString to src/__support/CPP/

libc/utils/testutils/OwnedString.h

14

This class holds the cpp::string so that it doesn't get deallocated, and is implicitly castable to char *.

In the test, the pattern is auto FILE_PATH = libc_make_test_file_path("filepath");, and then the FILE_PATH can be used as a char *. The actual type of FILE_PATH might be char* or OwnedString, but both work as char*.
We can't just have FILE_PATH be a cpp::string because cpp::string isn't implicitly castable to char*, and I'm trying to avoid needing a static cast every time the FILE_PATH is used.
Similarly, the FILE_PATH can't just be a char* since if we don't store the string it gets deallocated.
The original intent of this class was for FILE_PATH to always be an OwnedString, which is why it's a template, but that's not necessary now.

I've also moved this to __support/CPP/ since LibcTest.h says to only include headers from that folder and testutils.

[sivachandra]

libc/src/__support/CPP/string.h

116

Is this part of std::string, with the explicit tag?

libc/utils/testutils/OwnedString.h

14

So, two things you say:

1. Doesn't get deallocated.
2. Implicitly castable to char *.

I get #2 but can you explain #1 more?

[michaelrj]

respond to comments

libc/src/__support/CPP/string.h

116

no, I added it when I thought OwnedString would need to be templated so that both cpp::string and const char* arguments could be safely handled in the same way. I've removed it.

libc/utils/testutils/OwnedString.h

14

By "Doesn't get deallocated" I mean that if we made FILE_PATH a const char* and static cast the return value from libc_make_test_file_path to const char* then the cpp::string that libc_make_test_file_path returns would not be stored. The value of FILE_PATH would be set to the pointer to the buffer inside the cpp::string, then the cpp::string would be destructed, freeing that memory.

OwnedString solves this problem by owning the cpp::string and its memory, keeping it from being destructed until the end of the function.

[sivachandra]

libc/src/__support/CPP/OwnedString.h

1 ↗

(On Diff #515070)

This class should live outside of the CPP directory.

19 ↗

(On Diff #515070)

You can make this a template class like this:

template <typename T>
class CString {
  T str;
public:
  // These constructors can be implemented iff required.
  CString() = delete;
  CString(const CString &) = delete;
  CString(CString &&) = delete;

  LIBC_INLINE CString(const T &s) : str(s) {}
  LIBC_INLINE operator const char *() const { return str.data(); }
};

template <>
class CString<const char *> {
  const char *str;
public:
  // These constructors can be implemented iff required.
  CString() = delete;
  CString(const CString &) = delete;
  CString(CString &&) = delete;

  LIBC_INLINE CString(const char *s) : s(str) {}
  LIBC_INLINE operator const char *() const { return str; }
};

The template will work with cpp::string_view and cpp::span also.

libc/test/src/stdio/fprintf_test.cpp

38

This comment is for the OwnedString de-allocation problem you have explained.

This is working for you because FILE_PATH is actually a variable and not a temporary. Had you used like,

const char *FILE_PATH = libc_make_test_file_path(FILENAME);
::FILE *file = printf_test::fopen(FILE_PATH, "w");

on line 40, you would had the same de-allocation problem. Put other way around, if you make FILE_PATH a cpp::string instance, de-allocation will not happen until the end of this test's scope. The ability to implicitly convert it to a const char * value is still desirable, so I have added a comment under OwnedString.

[michaelrj]

address comments

libc/src/__support/CPP/OwnedString.h

1 ↗

(On Diff #515070)

I can't move it out of CPP because it's included from LibcTest.h and LibcTest.h specifies that it can only include headers from TestUtils and CPP.

19 ↗

(On Diff #515070)

I can't make this class a template because the function it's returning from would need to know the template arguments, since they can't be deduced in a function return type. Both the Bazel and CMake version of the function would therefore need to be the same template type.

[sivachandra]

libc/src/__support/CPP/OwnedString.h

1 ↗

(On Diff #515070)

That comment should be fixed. The previous testutils now live in __support.

libc/src/__support/CPP/cstring.h

18 ↗

(On Diff #516472)

Is this comment correct?

31 ↗

(On Diff #516472)

Whats the idea behind keeping a cstr member?

[michaelrj]

address comments

libc/src/__support/CPP/cstring.h

18 ↗

(On Diff #516472)

I think so. This class is primarily useful as a read-only string that may be dynamically allocated, but will automatically clean itself up. The primary use for that is as a return value.

31 ↗

(On Diff #516472)

the cstr member is used below in the const char* initializer. It allows this to hold either a cpp::string or a const char*.

[sivachandra]

libc/src/__support/cstring.h

21 ↗

(On Diff #516551)

The comment trail is on a different diff, but let me restart it here.

When you have:

cpp::string str("abc");

The var str holds a copy of "abc". Which means that str can be destroyed safely without worrying about the cpp::string's desctructor trying to free its resources. So, you shouldn't need cstr and also not need the constructor on line 34. If you have code like this:

CString str("abc");

The constructor on line 29 will be called as const char * is implicitly convertible to cpp::string: https://github.com/llvm/llvm-project/blob/main/libc/src/__support/CPP/string.h#L61.

The reason I suggested a template is because, in a general case, we should not try to copy const char * strings. You can do that adjustment later.

29 ↗

(On Diff #516551)

You should use LIBC_INLINE for code in src/

[michaelrj]

libc/src/__support/cstring.h

21 ↗

(On Diff #516551)

In my testing I'm not seeing the behavior you're describing. When I debug fprintf_test.cpp and look at which constructor CmakeFilePath.cpp is calling I see it using the one on line 34. I think what's happening is the compiler sees that the only call to CString is with a const char* and the version on line 29 is getting removed as unused from the final code since it's all inlined. Regardless, it's not constructing a non-trivial cpp::string.

[michaelrj]

move to LIBC_INLINE

[sivachandra]

libc/src/__support/cstring.h

21 ↗

(On Diff #516551)

In my testing I'm not seeing the behavior you're describing. When I debug fprintf_test.cpp and look at which constructor CmakeFilePath.cpp is calling I see it using the one on line 34.

That is because you have that constructor. Are you facing any problem if you remove that constructor?

[michaelrj]

remove unnecessary char* initializer for cstring and rename the header to c_string.h to clarify that this isn't related to cstring (the libc++ header).

libc/src/__support/CPP/string.h

public:
   LIBC_INLINE char &operator[](size_t index) { return data()[index]; }
 
   LIBC_INLINE const char *c_str() const { return data(); }
 
   LIBC_INLINE operator string_view() const {
     return string_view(buffer_, size_);
   }
 
+  LIBC_INLINE explicit operator char *() const { return buffer_; }
+
   LIBC_INLINE void reserve(size_t new_capacity) {
     ++new_capacity; // Accounting for the terminating '\0'
     if (new_capacity <= capacity_)
       return;
     // We extend the capacity to amortize buffer_ reallocations.
     // We choose to augment the value by 11 / 8, this is about +40% and division
     // by 8 is cheap. We guard the extension so the operation doesn't overflow.
     if (new_capacity < SIZE_MAX / 11)

libc/src/stdio/fprintf.cpp

 //===-- Implementation of fprintf -------------------------------*- 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/fprintf.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 {
 
 #ifndef LIBC_COPT_PRINTF_USE_SYSTEM_FILE
+#include "src/__support/File/file.h"
 using FileT = __llvm_libc::File;
 #else  // defined(LIBC_COPT_PRINTF_USE_SYSTEM_FILE)
 using FileT = ::FILE;
 #endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
 
 LLVM_LIBC_FUNCTION(int, fprintf,
                    (::FILE *__restrict stream, const char *__restrict format,
                     ...)) {

libc/test/UnitTest/BazelFilePath.cpp

+//===-- Implementation of the file path generator for bazel ---------------===//
+//
+// 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 "LibcTest.h"
+
+#include <stdlib.h>
+
+#include "src/__support/CPP/string.h"
+#include "utils/testutils/OwnedString.h"
+
+namespace __llvm_libc::testing {
+
+// This is the path to the folder bazel wants the test outputs written to.
+static const char *const UNDECLARED_OUTPUTS_PATH =
+    getenv("TEST_UNDECLARED_OUTPUTS_DIR");
+
+testutils::OwnedString<cpp::string>
+libc_make_test_file_path_func(const char *file_name) {
+  return cpp::string(UNDECLARED_OUTPUTS_PATH) + file_name;
+}
+
+} // namespace __llvm_libc::testing

libc/test/UnitTest/CMakeLists.txt

 add_library(
   TestLogger
   TestLogger.cpp
   TestLogger.h
 )
 target_include_directories(TestLogger PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(TestLogger
   libc.src.__support.CPP.string
   libc.src.__support.CPP.string_view
   libc.src.__support.OSUtil.osutil
 )
 
 add_library(
   LibcUnitTest
   Test.h
   LibcTest.cpp
+  CmakeFilePath.cpp
   LibcTest.h
 )
 target_include_directories(LibcUnitTest PUBLIC ${LIBC_SOURCE_DIR})
 add_dependencies(
   LibcUnitTest
   libc.src.__support.CPP.string
   libc.src.__support.CPP.string_view
   libc.src.__support.CPP.type_traits

libc/test/UnitTest/CmakeFilePath.cpp

+//===-- Implementation of the file path generator for cmake ---------------===//
+//
+// 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 "LibcTest.h"
+
+#include "src/__support/CPP/string.h"
+#include "utils/testutils/OwnedString.h"
+
+namespace __llvm_libc::testing {
+
+constexpr char PREFIX[] = "testdata/";
+
+testutils::OwnedString<cpp::string>
+libc_make_test_file_path_func(const char *file_name) {
+  return cpp::string(PREFIX) + file_name;
+}
+
+} // namespace __llvm_libc::testing

libc/test/UnitTest/LibcTest.h

 //===-- Base class for libc unittests ---------------------------*- 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_UTILS_UNITTEST_LIBCTEST_H
 #define LLVM_LIBC_UTILS_UNITTEST_LIBCTEST_H
 
+// This is defined as a simple macro in test.h so that it exists for platforms
+// that don't use our test infrastructure. It's defined as a proper function
+// below.
+#ifdef libc_make_test_file_path
+#undef libc_make_test_file_path
+#endif // libc_make_test_file_path
+
+// This macro takes a string literal and returns a value implicitly castable to
+// a const char*. That char* is the path to a file with the provided name in a
+// directory where the test is allowed to write. By default it uses the prefix
+// "testdata/", but implementations are allowed to redefine it as necessary.
+#define libc_make_test_file_path(file_name)                                    \
+  (__llvm_libc::testing::libc_make_test_file_path_func("" file_name))
+
 // This file can only include headers from src/__support/CPP/ or
 // utils/testutils. No other headers should be included.
 
 #include "PlatformDefs.h"
 
 #include "src/__support/CPP/string.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/type_traits.h"
 #include "utils/testutils/ExecuteFunction.h"
+#include "utils/testutils/OwnedString.h"
 #include "utils/testutils/StreamWrapper.h"
 
 namespace __llvm_libc {
 namespace testing {
 
 class RunContext;
 
 // Only the following conditions are supported. Notice that we do not have
template <typename... Types> struct TypeList {
   };
 };
 
 } // namespace internal
 
 // Make TypeList visible in __llvm_libc::testing.
 template <typename... Types> using TypeList = internal::TypeList<Types...>;
 
+testutils::OwnedString<cpp::string>
+libc_make_test_file_path_func(const char *file_name);
+
 } // namespace testing
 } // namespace __llvm_libc
 
 // For TYPED_TEST and TYPED_TEST_F below we need to display which type was used
 // to run the test. The default will return the fully qualified canonical type
 // but it can be difficult to read. We provide the following macro to allow the
 // client to register the type name as they see it in the code.
 #define REGISTER_TYPE_NAME(TYPE)                                               \

libc/test/UnitTest/Test.h

 //===-- Header selector for libc unittests ----------------------*- 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_UTILS_UNITTEST_TEST_H
 #define LLVM_LIBC_UTILS_UNITTEST_TEST_H
 
+// This macro takes a string literal and returns a value implicitly castable to
+// a const char*. That char* is the path to a file with the provided name in a
+// directory where the test is allowed to write. By default it uses the prefix
+// "testdata/", but implementations are allowed to redefine it as necessary.
+#define libc_make_test_file_path(file_name) ("testdata/" file_name)
+
 #ifdef LIBC_COPT_TEST_USE_FUCHSIA
 #include "FuchsiaTest.h"
 #elif defined(LIBC_COPT_TEST_USE_PIGWEED)
 #include "PigweedTest.h"
 #else
 #include "LibcTest.h"
 #endif
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_TEST_H

libc/test/src/stdio/fprintf_test.cpp

 using ::fclose;
 using ::ferror;
 using ::fopen;
 using ::fread;
 #endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
 } // namespace printf_test
 
 TEST(LlvmLibcFPrintfTest, WriteToFile) {
-  constexpr char FILENAME[] = "testdata/fprintf_output.test";
-  ::FILE *file = printf_test::fopen(FILENAME, "w");
+  auto FILE_PATH = libc_make_test_file_path("fprintf_output.test");
+
+  ::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 = __llvm_libc::fprintf(file, simple);
   EXPECT_EQ(written, 37);
 
   constexpr char numbers[] = "1234567890\n";
   written = __llvm_libc::fprintf(file, "%s", numbers);
   EXPECT_EQ(written, 11);
 
   constexpr char format_more[] = "%s and more\n";
   constexpr char short_numbers[] = "1234";
   written = __llvm_libc::fprintf(file, format_more, short_numbers);
   EXPECT_EQ(written, 14);
 
   ASSERT_EQ(0, printf_test::fclose(file));
 
-  file = printf_test::fopen(FILENAME, "r");
+  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),

libc/utils/testutils/CMakeLists.txt

add_library(
   StreamWrapper.h
   ${EFFile}
   ExecuteFunction.h
   ${FDReaderFile}
   FDReader.h
   Timer.h
   Timer.cpp
   RoundingModeUtils.cpp
+  OwnedString.h
 )

libc/utils/testutils/OwnedString.h

+//===-- Implementation of a struct to hold a string in menory -------------===//
+//
+// 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_UTILS_TESTUTILS_OWNEDSTRING_H
+#define LLVM_LIBC_UTILS_TESTUTILS_OWNEDSTRING_H
+
+namespace __llvm_libc::testutils {
+
+template <typename Str_T> class OwnedString {
+  Str_T str;
+  const char *cstr;
+
+public:
+  inline OwnedString(Str_T in_str) {
+    str = in_str;
+    cstr = static_cast<const char *>(str);
+  }
+
+  inline operator const char *() const { return cstr; }
+};
+} // namespace __llvm_libc::testutils
+
+#endif // LLVM_LIBC_UTILS_TESTUTILS_OWNEDSTRING_H

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

 # This file is licensed 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
 
 # LLVM libc project.
 load(
     ":libc_build_rules.bzl",
+    "PRINTF_COPTS",
     "libc_function",
     "libc_math_function",
     "libc_support_library",
 )
 load(":platforms.bzl", "PLATFORM_CPU_ARM64", "PLATFORM_CPU_X86_64")
 load("@bazel_skylib//lib:selects.bzl", "selects")
 load("@bazel_skylib//rules:common_settings.bzl", "string_flag")
 
libc_support_library(
     hdrs = ["src/__support/CPP/cstddef.h"],
     deps = [
         ":__support_cpp_type_traits",
         ":libc_root",
     ],
 )
 
 libc_support_library(
+    name = "__support_cpp_expected",
+    hdrs = ["src/__support/CPP/expected.h"],
+    deps = [
+        ":libc_root",
+    ],
+)
+
+libc_support_library(
     name = "__support_cpp_functional",
     hdrs = ["src/__support/CPP/functional.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_cpp_limits",
     hdrs = ["src/__support/CPP/limits.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
+    name = "__support_cpp_new",
+    srcs = ["src/__support/CPP/new.cpp"],
+    hdrs = ["src/__support/CPP/new.h"],
+    deps = [
+        ":__support_common",
+        ":libc_root",
+    ],
+)
+
+libc_support_library(
     name = "__support_cpp_optional",
     hdrs = ["src/__support/CPP/optional.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_cpp_span",
     hdrs = ["src/__support/CPP/span.h"],
libc_support_library(
     hdrs = ["src/__support/arg_list.h"],
     deps = [
         ":__support_common",
         ":libc_root",
     ],
 )
 
 libc_support_library(
+    name = "__support_error_or",
+    hdrs = ["src/__support/error_or.h"],
+    deps = [
+        ":__support_common",
+        ":__support_cpp_expected",
+        ":libc_root",
+    ],
+)
+
+libc_support_library(
     name = "__support_float_to_string",
     hdrs = [
         "src/__support/float_to_string.h",
         "src/__support/ryu_constants.h",
     ],
     deps = [
         ":__support_common",
         ":__support_cpp_type_traits",
deps = [
         ":__support_common",
         ":__support_cpp_type_traits",
         ":__support_fputil_fp_bits",
         ":libc_root",
     ],
 )
 
 libc_support_library(
+    name = "__support_file_file",
+    srcs = ["src/__support/File/file.cpp"],
+    hdrs = ["src/__support/File/file.h"],
+    deps = [
+        ":__support_cpp_new",
+        ":__support_cpp_span",
+        ":__support_error_or",
+        ":__support_threads_mutex",
+        ":errno",
+        ":libc_root",
+    ],
+)
+
+libc_support_library(
     name = "__support_named_pair",
     hdrs = ["src/__support/named_pair.h"],
     deps = [":libc_root"],
 )
 
 libc_support_library(
     name = "__support_builtin_wrappers",
     hdrs = ["src/__support/builtin_wrappers.h"],
textual_hdrs = [
         #TODO: add support for GPU quick_exit (isn't just in a header.)
     ],
     deps = [
         ":__support_osutil_syscall",
         ":libc_root",
     ],
 )
 
+libc_support_library(
+    name = "__support_threads_mutex",
+    hdrs = [
+        "src/__support/threads/mutex.h",
+        "src/__support/threads/mutex_common.h",
+    ],
+    textual_hdrs = [
+        "src/__support/threads/linux/mutex.h",
+        "src/__support/threads/linux/futex_word.h",
+    ],
+    deps = [
+        ":__support_cpp_atomic",
+        ":__support_osutil_syscall",
+        ":libc_root",
+    ],
+)
+
 ############################### errno targets ################################
 
 libc_function(
     name = "errno",
     srcs = ["src/errno/libc_errno.cpp"],
     hdrs = ["src/errno/libc_errno.h"],
     deps = [
         ":__support_common",
libc_function(
     ],
 )
 
 ################################ stdio targets #################################
 
 libc_support_library(
     name = "printf_core_structs",
     hdrs = ["src/stdio/printf_core/core_structs.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_cpp_string_view",
         ":__support_fputil_fp_bits",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "printf_config",
     hdrs = ["src/stdio/printf_core/printf_config.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "printf_parser",
     srcs = ["src/stdio/printf_core/parser.cpp"],
     hdrs = ["src/stdio/printf_core/parser.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_arg_list",
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_optional",
         ":__support_cpp_string_view",
         ":__support_cpp_type_traits",
         ":__support_ctype_utils",
         ":__support_fputil_fp_bits",
         ":__support_str_to_integer",
         ":libc_root",
         ":printf_config",
         ":printf_core_structs",
     ],
 )
 
 # Only used for testing.
 libc_support_library(
     name = "printf_mock_parser",
     srcs = ["src/stdio/printf_core/parser.cpp"],
     hdrs = ["src/stdio/printf_core/parser.h"],
-    copts = ["-DLIBC_COPT_MOCK_ARG_LIST"],
+    copts = PRINTF_COPTS + ["-DLIBC_COPT_MOCK_ARG_LIST"],
     deps = [
         ":__support_arg_list",
         ":__support_common",
         ":__support_cpp_bit",
         ":__support_cpp_optional",
         ":__support_cpp_string_view",
         ":__support_cpp_type_traits",
         ":__support_ctype_utils",
         ":__support_fputil_fp_bits",
         ":__support_str_to_integer",
         ":libc_root",
         ":printf_config",
         ":printf_core_structs",
     ],
 )
 
 libc_support_library(
     name = "printf_string_writer",
     srcs = ["src/stdio/printf_core/string_writer.cpp"],
     hdrs = ["src/stdio/printf_core/string_writer.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_cpp_string_view",
         ":libc_root",
         ":printf_core_structs",
         ":string_memory_utils",
     ],
 )
 
 libc_support_library(
+    name = "printf_file_writer",
+    hdrs = ["src/stdio/printf_core/file_writer.h"],
+    copts = PRINTF_COPTS,
+    deps = [
+        ":__support_cpp_string_view",
+        ":__support_file_file",
+        ":libc_root",
+        ":printf_core_structs",
+    ],
+)
+
+libc_support_library(
     name = "printf_writer",
     srcs = ["src/stdio/printf_core/writer.cpp"],
     hdrs = ["src/stdio/printf_core/writer.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_cpp_string_view",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "printf_converter",
     srcs = ["src/stdio/printf_core/converter.cpp"],
     hdrs = [
         "src/stdio/printf_core/char_converter.h",
         "src/stdio/printf_core/converter.h",
         "src/stdio/printf_core/converter_atlas.h",
         "src/stdio/printf_core/converter_utils.h",
         "src/stdio/printf_core/float_dec_converter.h",
         "src/stdio/printf_core/float_hex_converter.h",
         "src/stdio/printf_core/float_inf_nan_converter.h",
         "src/stdio/printf_core/int_converter.h",
         "src/stdio/printf_core/ptr_converter.h",
         "src/stdio/printf_core/string_converter.h",
         "src/stdio/printf_core/write_int_converter.h",
     ],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_common",
         ":__support_cpp_limits",
         ":__support_cpp_span",
         ":__support_cpp_string_view",
         ":__support_float_to_string",
         ":__support_fputil_fenv_impl",
         ":__support_fputil_fp_bits",
         ":__support_integer_to_string",
         ":__support_libc_assert",
         ":__support_uint",
         ":__support_uint128",
         ":libc_root",
         ":printf_core_structs",
         ":printf_writer",
     ],
 )
 
 libc_support_library(
     name = "printf_main",
     srcs = ["src/stdio/printf_core/printf_main.cpp"],
     hdrs = ["src/stdio/printf_core/printf_main.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_arg_list",
         ":libc_root",
         ":printf_converter",
         ":printf_core_structs",
         ":printf_parser",
         ":printf_writer",
     ],
 )
 
 libc_function(
     name = "sprintf",
     srcs = ["src/stdio/sprintf.cpp"],
     hdrs = ["src/stdio/sprintf.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_arg_list",
         ":errno",
         ":printf_main",
         ":printf_string_writer",
         ":printf_writer",
     ],
 )
 
 libc_function(
     name = "snprintf",
     srcs = ["src/stdio/snprintf.cpp"],
     hdrs = ["src/stdio/snprintf.h"],
+    copts = PRINTF_COPTS,
     deps = [
         ":__support_arg_list",
         ":errno",
         ":printf_main",
         ":printf_string_writer",
         ":printf_writer",
     ],
 )
+
+libc_support_library(
+    name = "vfprintf_internal",
+    hdrs = ["src/stdio/printf_core/vfprintf_internal.h"],
+    copts = PRINTF_COPTS,
+    deps = [
+        ":__support_arg_list",
+        ":__support_file_file",
+        ":__support_macros_attributes",
+        ":printf_file_writer",
+        ":printf_main",
+        ":printf_writer",
+    ],
+)
+
+libc_function(
+    name = "printf",
+    srcs = ["src/stdio/printf.cpp"],
+    hdrs = ["src/stdio/printf.h"],
+    copts = PRINTF_COPTS,
+    deps = [
+        ":__support_arg_list",
+        ":errno",
+        ":vfprintf_internal",
+    ],
+)
+
+libc_function(
+    name = "fprintf",
+    srcs = ["src/stdio/fprintf.cpp"],
+    hdrs = ["src/stdio/fprintf.h"],
+    copts = PRINTF_COPTS,
+    deps = [
+        ":__support_arg_list",
+        ":errno",
+        ":vfprintf_internal",
+    ],
+)

utils/bazel/llvm-project-overlay/libc/libc_build_rules.bzl

 # This file is licensed 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
 
 """LLVM libc starlark rules for building individual functions."""
 
 load(":platforms.bzl", "PLATFORM_CPU_ARM64", "PLATFORM_CPU_X86_64")
 load("@bazel_skylib//lib:selects.bzl", "selects")
 
 LIBC_ROOT_TARGET = ":libc_root"
 INTERNAL_SUFFIX = ".__internal__"
 
+PRINTF_COPTS = [
+    "-DLIBC_COPT_PRINTF_USE_SYSTEM_FILE",
+    "-DLIBC_COPT_PRINTF_DISABLE_INDEX_MODE",
+    "-DLIBC_COPT_PRINTF_DISABLE_WRITE_INT",
+]
+
 def _libc_library(name, copts = None, **kwargs):
     """Internal macro to serve as a base for all other libc library rules.
 
     Args:
       name: Target name.
       copts: The special compiler options for the target.
       **kwargs: All other attributes relevant for the cc_library rule.
     """
     copts = copts or []
 
     # We want all libc sources to be compiled with "hidden" visibility.
     # The public symbols will be given "default" visibility explicitly.
     # See src/__support/common.h for more information.
-    copts.append("-fvisibility=hidden")
+    copts = copts + ["-fvisibility=hidden"]
     native.cc_library(
         name = name,
         copts = copts,
         linkstatic = 1,
         **kwargs
     )
 
 # A convenience var which should be used to list all libc support libraries.
Args:
       deps: The list of target dependencies if any.
       copts: The list of options to add to the C++ compilation command.
       local_defines: The preprocessor defines which will be prepended with -D
                      and passed to the compile command of this target but not
                      its deps.
       **kwargs: Other attributes relevant for a cc_library. For example, deps.
     """
     deps = deps or []
-    deps.append(LIBC_ROOT_TARGET)
+    # We use the explicit equals pattern here because append and += mutate the
+    # original list, where this creates a new list and stores it in deps.
+    deps = deps + [LIBC_ROOT_TARGET]
     copts = copts or []
-    copts.append("-O3")
-    copts.append("-fno-builtin")
-    copts.append("-fno-lax-vector-conversions")
+    copts = copts + ["-O3", "-fno-builtin", "-fno-lax-vector-conversions"]
 
     # We compile the code twice, the first target is suffixed with ".__internal__" and contains the
     # C++ functions in the "__llvm_libc" namespace. This allows us to test the function in the
     # presence of another libc.
     native.cc_library(
         name = name + INTERNAL_SUFFIX,
         srcs = srcs,
         deps = deps,
         copts = copts,
         linkstatic = 1,
         **kwargs
     )
 
     # This second target is the llvm libc C function.
 
     func_attrs = ["__attribute__((visibility(\"default\")))"]
     if weak:
-        func_attrs.append("__attribute__((weak))")
+        func_attrs = func_attrs + ["__attribute__((weak))"]
     local_defines = local_defines or ["LIBC_COPT_PUBLIC_PACKAGING"]
-    local_defines.append("LLVM_LIBC_FUNCTION_ATTR='%s'" % " ".join(func_attrs))
+    local_defines = local_defines + ["LLVM_LIBC_FUNCTION_ATTR='%s'" % " ".join(func_attrs)]
     _libc_library(
         name = name,
         srcs = srcs,
         deps = deps,
         copts = copts,
         local_defines = local_defines,
         **kwargs
     )

utils/bazel/llvm-project-overlay/libc/test/UnitTest/BUILD.bazel

deps = [
         "//libc:__support_osutil_io",
         "//libc:libc_root",
     ],
 )
 
 cc_library(
     name = "LibcUnitTest",
     srcs = [
+        "BazelFilePath.cpp",
         "LibcTest.cpp",
         "LibcTestMain.cpp",
     ],
     hdrs = [
         "LibcTest.h",
         "PlatformDefs.h",
         "Test.h",
     ],

utils/bazel/llvm-project-overlay/libc/test/libc_test_rules.bzl

 # This file is licensed 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
 
 """LLVM libc starlark rules for tests.
 
 libc functions are created though the libc_build_rules.bzl:libc_function.
 They come in two flavors:
  - the internal one that is scoped into the `__llvm_libc` namespace.
  - the libc one that is the regular C function.
 
 When performing tests we make sure to always use the internal version.
 """
 
 load("//libc:libc_build_rules.bzl", "INTERNAL_SUFFIX")
 
-def libc_test(name, srcs, libc_function_deps, deps = [], **kwargs):
+def libc_test(name, srcs, libc_function_deps, deps = [], output_file = "", **kwargs):
     """Add target for a libc test.
 
     Args:
       name: Test target name
       srcs: List of sources for the test.
       libc_function_deps: List of libc_function targets used by this test.
       deps: The list of other libraries to be linked in to the test target.
       **kwargs: Attributes relevant for a cc_test. For example, name, srcs.

utils/bazel/llvm-project-overlay/libc/test/src/stdio/BUILD.bazel

 # This file is licensed 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
 
 # Tests for LLVM libc stdio.h functions.
 
 load("//libc/test:libc_test_rules.bzl", "libc_test")
+load("//libc:libc_build_rules.bzl", "PRINTF_COPTS")
 
 package(default_visibility = ["//visibility:public"])
 
 licenses(["notice"])
 
 libc_test(
     name = "printf_parser_test",
     srcs = ["printf_core/parser_test.cpp"],
     libc_function_deps = [
     ],
     deps = [
       "//libc:printf_parser",
       "//libc:printf_core_structs",
       "//libc:__support_cpp_string_view",
       "//libc:__support_cpp_bit",
       "//libc:__support_arg_list",
       "//libc/utils/testutils:libc_test_utils",
       "//libc/test/UnitTest:printf_matcher",
     ],
+    copts = PRINTF_COPTS,
 )
 
 libc_test(
     name = "printf_string_writer_test",
     srcs = ["printf_core/string_writer_test.cpp"],
     libc_function_deps = [
     ],
     deps = [
       "//libc:printf_string_writer",
       "//libc:printf_writer",
       "//libc:printf_core_structs",
       "//libc:__support_cpp_string_view",
       "//libc:__support_arg_list",
     ],
+    copts = PRINTF_COPTS,
 )
 
 libc_test(
     name = "printf_converter_test",
     srcs = ["printf_core/converter_test.cpp"],
     libc_function_deps = [
     ],
     deps = [
       "//libc:printf_converter",
       "//libc:printf_string_writer",
       "//libc:printf_writer",
       "//libc:printf_core_structs",
       "//libc:__support_cpp_string_view",
       "//libc:__support_arg_list",
     ],
+    copts = PRINTF_COPTS,
 )
 
 libc_test(
     name = "sprintf_test",
     srcs = ["sprintf_test.cpp"],
     libc_function_deps = [
         "//libc:sprintf",
     ],
     deps = [
       "//libc:__support_fputil_fp_bits",
       "//libc:__support_fputil_platform_defs",
       "//libc/utils/testutils:libc_test_utils",
     ],
+    copts = PRINTF_COPTS,
 )
 
 libc_test(
     name = "snprintf_test",
     srcs = ["snprintf_test.cpp"],
     libc_function_deps = [
         "//libc:snprintf",
     ],
+    copts = PRINTF_COPTS,
+)
+
+libc_test(
+    name = "printf_test",
+    srcs = ["printf_test.cpp"],
+    libc_function_deps = [
+        "//libc:printf",
+    ],
+    copts = PRINTF_COPTS,
+)
+
+libc_test(
+    name = "fprintf_test",
+    srcs = ["fprintf_test.cpp"],
+    libc_function_deps = [
+        "//libc:fprintf",
+    ],
+    copts = PRINTF_COPTS,
 )

utils/bazel/llvm-project-overlay/libc/utils/testutils/BUILD.bazel

srcs = [
         "ExecuteFunctionUnix.cpp",
         "FDReaderUnix.cpp",
         "RoundingModeUtils.cpp",
         "StreamWrapper.cpp",
     ],
     hdrs = [
         "ExecuteFunction.h",
         "FDReader.h",
+        "OwnedString.h",
         "RoundingModeUtils.h",
         "StreamWrapper.h",
     ],
     deps = [
         "//libc:libc_root",
         "//llvm:Support",
     ],
 )