[libc][NFC] Make tuning macros start with LIBC_COPT_

[gchatelet]

Summary

Rename preprocessor definitions that control tuning of llvm libc.

[gchatelet]

• Keep CMake option as is, only change preprocessor

[gchatelet]

@michaelrj it seems that the following definitions are currently not exposed to the build system.
LIBC_COPT_PRINTF_CONV_ATLAS
LIBC_COPT_PRINTF_DISABLE_FLOAT
LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
LIBC_COPT_PRINTF_DISABLE_WRITE_INT
LIBC_COPT_PRINTF_INDEX_ARR_LEN
LIBC_COPT_PRINTF_CONV_ATLAS
LIBC_COPT_SCANF_DISABLE_FLOAT
LIBC_COPT_SCANF_DISABLE_INDEX_MODE
LIBC_COPT_DISABLE_CLINGER_FAST_PATH
LIBC_COPT_DISABLE_EISEL_LEMIRE
LIBC_COPT_DISABLE_SIMPLE_DECIMAL_CONVERSION

Also for the last three ones we should scope it, any suggestions ? How about LIBC_COPT_STRTOFLOAT_DISABLE_ ?

[gchatelet]

libc/test/src/math/RoundToIntegerTest.h

87–90

@lntue I'm unsure what this is about so I didn't rename it. Is it supposed to be exposed at some point?
There is a CMake option here but it is not sufficient to pass the option down to the C++ code.

[lntue]

libc/test/src/math/RoundToIntegerTest.h

87–90

I think we planned to have a section on the documentations about all the implementation-defined cases where we are different from glibc and maybe provide these flags for users.

[michaelrj]

The flags for my pieces don't have cmake options because I didn't know how we were going to organize them at first.

For printf:
Disable float, disable index mode, and disable write int are all independent flags. They can have simple options and I think they should default to off, off, and on respectively (so that we only disable write int).
Index arr len is takes an int, but it's already got a default in printf_config.h so its cmake options should probably default to off.
Conv atlas is intended to let users completely replace the conversion logic, since it defines where the header file that includes all the headers that define the converters is. I'd say it probably shouldn't have a cmake option at all, since the cmake targets that define the header libraries for the conversions would also need to be changed. Basically, it's for people who are using their own build system and want to use their own conversions.

For scanf:
Disable float and index mode are the same as in printf.

For strtofloat:
Scoping those options seems like a good idea. They can similarly have simple options, although it might be good to have a warning pop up when disabling simple decimal conversion since that means there's no guarantee of correctness.

[gchatelet]

@phosek @mcgrathr this patch would also rename LLVM_LIBC_TEST_USE_FUCHSIA to LIBC_COPT_TEST_USE_FUCHSIA to conform to our guidelines.
Let me know if that's an issue for you.

libc/test/src/math/RoundToIntegerTest.h

87–90

So IIUC this is a customization point and it should be renamed.
I'll do so, let me know if you think otherwise.

[gchatelet]

• rename LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR as well
• Scope str_to_float macros and add a warning

[gchatelet]

In D143913#4123628, @michaelrj wrote:

The flags for my pieces don't have cmake options because I didn't know how we were going to organize them at first.

For printf:
Disable float, disable index mode, and disable write int are all independent flags. They can have simple options and I think they should default to off, off, and on respectively (so that we only disable write int).
Index arr len is takes an int, but it's already got a default in printf_config.h so its cmake options should probably default to off.
Conv atlas is intended to let users completely replace the conversion logic, since it defines where the header file that includes all the headers that define the converters is. I'd say it probably shouldn't have a cmake option at all, since the cmake targets that define the header libraries for the conversions would also need to be changed. Basically, it's for people who are using their own build system and want to use their own conversions.

For scanf:
Disable float and index mode are the same as in printf.

For strtofloat:
Scoping those options seems like a good idea. They can similarly have simple options, although it might be good to have a warning pop up when disabling simple decimal conversion since that means there's no guarantee of correctness.

Thx for the detailed answer!
I've scoped the strtofloat macros. I'll expose the options in a subsequent patch.

[michaelrj]

LGTM for my options. Thank you for doing this!

libc/cmake/modules/LLVMLibCObjectRules.cmake

add_library(${gpu_target_name}
       OBJECT
       ${ADD_GPU_ENTRYPOINT_OBJ_SRCS}
       ${ADD_GPU_ENTRYPOINT_OBJ_HDRS}
     )
 
     target_compile_options(${gpu_target_name} PRIVATE ${compile_options})
     target_include_directories(${gpu_target_name} PRIVATE ${include_dirs})
     add_dependencies(${gpu_target_name} ${ADD_GPU_ENTRYPOINT_OBJ_DEPENDS})
-    target_compile_definitions(${gpu_target_name} PRIVATE LLVM_LIBC_PUBLIC_PACKAGING)
+    target_compile_definitions(${gpu_target_name} PRIVATE LIBC_COPT_PUBLIC_PACKAGING)
 
     # Append this target to a list of images to package into a single binary.
     set(input_file $<TARGET_OBJECTS:${gpu_target_name}>)
     list(APPEND packager_images
          --image=file=${input_file},arch=${gpu_arch},triple=${gpu_target_triple})
     list(APPEND gpu_target_names ${gpu_target_name})
   endforeach()
 
add_library(
       ${fq_target_name}
       # We want an object library as the objects will eventually get packaged into
       # an archive (like libc.a).
       EXCLUDE_FROM_ALL
       OBJECT
       ${ADD_ENTRYPOINT_OBJ_SRCS}
       ${ADD_ENTRYPOINT_OBJ_HDRS}
     )
-    target_compile_options(${fq_target_name} BEFORE PRIVATE ${common_compile_options} -DLLVM_LIBC_PUBLIC_PACKAGING)
+    target_compile_options(${fq_target_name} BEFORE PRIVATE ${common_compile_options} -DLIBC_COPT_PUBLIC_PACKAGING)
     target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
     add_dependencies(${fq_target_name} ${full_deps_list})
 
     set_target_properties(
       ${fq_target_name}
       PROPERTIES
         ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
         TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}

libc/common_libc_tuners.cmake

 # ------------------------------------------------------------------------------
 # Common tuning option definitions.
 # ------------------------------------------------------------------------------
 
 set(LIBC_COMMON_TUNE_OPTIONS "")
 
 option(LIBC_UNSAFE_STRING_WIDE_READ "Functions searching for the first character in a string such as strlen will read the string as int sized blocks instead of bytes. This relies on undefined behavior and may fail on some systems, but improves performance on long strings." OFF)
 if(LIBC_UNSAFE_STRING_WIDE_READ)
   if(LLVM_USE_SANITIZER)
     message(FATAL_ERROR "LIBC_UNSAFE_STRING_WIDE_READ is set at the same time as a sanitizer. LIBC_UNSAFE_STRING_WIDE_READ causes strlen and memchr to read beyond the end of their target strings, which is undefined behavior caught by sanitizers.")
   else()
-    list(APPEND LIBC_COMMON_TUNE_OPTIONS "-DLIBC_UNSAFE_STRING_WIDE_READ")
+    list(APPEND LIBC_COMMON_TUNE_OPTIONS "-DLIBC_COPT_UNSAFE_STRING_WIDE_READ")
     endif()
 endif()

libc/fuzzing/stdlib/CMakeLists.txt

DEPENDS
     libc.src.stdlib.atoi
     libc.src.stdlib.atol
     libc.src.stdlib.atoll
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull
   COMPILE_OPTIONS
-    -DLLVM_LIBC_FUZZ_ATOI_CLEANER_INPUT
+    -DLIBC_COPT_FUZZ_ATOI_CLEANER_INPUT
 )
 
 add_libc_fuzzer(
   strtointeger_fuzz
   SRCS
     strtointeger_fuzz.cpp
   DEPENDS
     libc.src.stdlib.atoi
     libc.src.stdlib.atol
     libc.src.stdlib.atoll
     libc.src.stdlib.strtol
     libc.src.stdlib.strtoll
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull
 )

libc/fuzzing/stdlib/strtointeger_differential_fuzz.cpp

 // of getting long numbers very low.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   uint8_t *container = new uint8_t[size + 1];
   if (!container)
     __builtin_trap();
   size_t i;
 
   for (i = 0; i < size; ++i) {
-#ifdef LLVM_LIBC_FUZZ_ATOI_CLEANER_INPUT
+#ifdef LIBC_COPT_FUZZ_ATOI_CLEANER_INPUT
     container[i] = VALID_CHARS[data[i] % sizeof(VALID_CHARS)];
 #else
     container[i] = data[i];
 #endif
   }
   container[size] = '\0'; // Add null terminator to container.
   // the first character is interpreted as the base, so it should be fully
   // random even when the input is cleaned.

libc/src/__support/common.h

 #include "src/__support/macros/attributes.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #ifndef LLVM_LIBC_FUNCTION_ATTR
 #define LLVM_LIBC_FUNCTION_ATTR
 #endif
 
 // GPU targets do not support aliasing.
-#if defined(LLVM_LIBC_PUBLIC_PACKAGING) && defined(LIBC_TARGET_ARCH_IS_GPU)
+#if defined(LIBC_COPT_PUBLIC_PACKAGING) && defined(LIBC_TARGET_ARCH_IS_GPU)
 #define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
   LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name)                          \
       __##name##_impl__ __asm__(#name);                                        \
   type __##name##_impl__ arglist
 // MacOS needs to be excluded because it does not support aliasing.
-#elif defined(LLVM_LIBC_PUBLIC_PACKAGING) && (!defined(__APPLE__))
+#elif defined(LIBC_COPT_PUBLIC_PACKAGING) && (!defined(__APPLE__))
 #define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
   LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name)                          \
       __##name##_impl__ __asm__(#name);                                        \
   decltype(__llvm_libc::name) name [[gnu::alias(#name)]];                      \
   type __##name##_impl__ arglist
 #else
 #define LLVM_LIBC_FUNCTION(type, name, arglist) type name arglist
 #endif

libc/src/__support/str_to_float.h

decimal_exp_to_float(typename fputil::FPBits<T>::UIntType mantissa,
   // If the exponent is too small even for a subnormal, return 0.
   if (exp10 < get_lower_bound<T>()) {
     *outputMantissa = 0;
     *outputExp2 = 0;
     errno = ERANGE;
     return;
   }
 
-#ifndef LLVM_LIBC_DISABLE_CLINGER_FAST_PATH
+#ifndef LIBC_COPT_STRTOFLOAT_DISABLE_CLINGER_FAST_PATH
   if (!truncated) {
     if (clinger_fast_path<T>(mantissa, exp10, outputMantissa, outputExp2)) {
       return;
     }
   }
-#endif // LLVM_LIBC_DISABLE_CLINGER_FAST_PATH
+#endif // LIBC_COPT_STRTOFLOAT_DISABLE_CLINGER_FAST_PATH
 
-#ifndef LLVM_LIBC_DISABLE_EISEL_LEMIRE
+#ifndef LIBC_COPT_STRTOFLOAT_DISABLE_EISEL_LEMIRE
   // Try Eisel-Lemire
   if (eisel_lemire<T>(mantissa, exp10, outputMantissa, outputExp2)) {
     if (!truncated) {
       return;
     }
     // If the mantissa is truncated, then the result may be off by the LSB, so
     // check if rounding the mantissa up changes the result. If not, then it's
     // safe, else use the fallback.
     typename fputil::FPBits<T>::UIntType first_mantissa = *outputMantissa;
     uint32_t first_exp2 = *outputExp2;
     if (eisel_lemire<T>(mantissa + 1, exp10, outputMantissa, outputExp2)) {
       if (*outputMantissa == first_mantissa && *outputExp2 == first_exp2) {
         return;
       }
     }
   }
-#endif // LLVM_LIBC_DISABLE_EISEL_LEMIRE
+#endif // LIBC_COPT_STRTOFLOAT_DISABLE_EISEL_LEMIRE
 
-#ifndef LLVM_LIBC_DISABLE_SIMPLE_DECIMAL_CONVERSION
+#ifndef LIBC_COPT_STRTOFLOAT_DISABLE_SIMPLE_DECIMAL_CONVERSION
   simple_decimal_conversion<T>(numStart, outputMantissa, outputExp2);
-#endif // LLVM_LIBC_DISABLE_SIMPLE_DECIMAL_CONVERSION
+#else
+#warning "Simple decimal conversion is disabled, result may not be correct."
+#endif // LIBC_COPT_STRTOFLOAT_DISABLE_SIMPLE_DECIMAL_CONVERSION
 
   return;
 }
 
 // Takes a mantissa and base 2 exponent and converts it into its closest
 // floating point type T equivalient. Since the exponent is already in the right
 // form, this is mostly just shifting and rounding. This is used for hexadecimal
 // numbers since a base 16 exponent multiplied by 4 is the base 2 exponent.

libc/src/stdio/printf_core/converter.cpp

 //===-- Format specifier converter implmentation 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/converter.h"
 
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/writer.h"
 
 // This option allows for replacing all of the conversion functions with custom
 // replacements. This allows conversions to be replaced at compile time.
-#ifndef LLVM_LIBC_PRINTF_CONV_ATLAS
+#ifndef LIBC_COPT_PRINTF_CONV_ATLAS
 #include "src/stdio/printf_core/converter_atlas.h"
 #else
-#include LLVM_LIBC_PRINTF_CONV_ATLAS
+#include LIBC_COPT_PRINTF_CONV_ATLAS
 #endif
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int convert(Writer *writer, const FormatSection &to_conv) {
case 's':
     return convert_string(writer, to_conv);
   case 'd':
   case 'i':
   case 'u':
   case 'o':
   case 'x':
   case 'X':
     return convert_int(writer, to_conv);
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
   case 'f':
   case 'F':
     return convert_float_decimal(writer, to_conv);
   case 'e':
   case 'E':
     return convert_float_dec_exp(writer, to_conv);
   case 'a':
   case 'A':
     return convert_float_hex_exp(writer, to_conv);
   case 'g':
   case 'G':
     return convert_float_dec_auto(writer, to_conv);
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
-#ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
   case 'n':
     return convert_write_int(writer, to_conv);
-#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
   case 'p':
     return convert_pointer(writer, to_conv);
   default:
     return writer->write(to_conv.raw_string);
   }
   return -1;
 }
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/converter_atlas.h

 #include "src/stdio/printf_core/string_converter.h"
 
 // defines convert_char
 #include "src/stdio/printf_core/char_converter.h"
 
 // defines convert_int
 #include "src/stdio/printf_core/int_converter.h"
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
 // defines convert_float_decimal
 // defines convert_float_dec_exp
 // defines convert_float_dec_auto
 #include "src/stdio/printf_core/float_dec_converter.h"
 // defines convert_float_hex_exp
 #include "src/stdio/printf_core/float_hex_converter.h"
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
 #include "src/stdio/printf_core/write_int_converter.h"
-#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
 
 // defines convert_pointer
 #include "src/stdio/printf_core/ptr_converter.h"
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_ATLAS_H

libc/src/stdio/printf_core/parser.h

 namespace printf_core {
 
 class Parser {
   const char *__restrict str;
 
   size_t cur_pos = 0;
   internal::ArgList args_cur;
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
   // args_start stores the start of the va_args, which is allows getting the
   // value of arguments that have already been passed. args_index is tracked so
   // that we know which argument args_cur is on.
   internal::ArgList args_start;
   size_t args_index = 1;
 
   // Defined in printf_config.h
-  static constexpr size_t DESC_ARR_LEN = LLVM_LIBC_PRINTF_INDEX_ARR_LEN;
+  static constexpr size_t DESC_ARR_LEN = LIBC_COPT_PRINTF_INDEX_ARR_LEN;
 
   // desc_arr stores the sizes of the variables in the ArgList. This is used in
   // index mode to reduce repeated string parsing. The sizes are stored as
   // TypeDesc objects, which store the size as well as minimal type information.
   // This is necessary because some systems separate the floating point and
   // integer values in va_args.
   TypeDesc desc_arr[DESC_ARR_LEN] = {{0, Integer}};
 
   // TODO: Look into object stores for optimization.
 
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 public:
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
   LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args), args_start(args) {}
 #else
   LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args) {}
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its
   // variables stored in the format section.
   FormatSection get_next_section();
 
 private:
private:
   template <class T> LIBC_INLINE T get_next_arg_value() {
     return args_cur.next_var<T>();
   }
 
   //----------------------------------------------------
   // INDEX MODE ONLY FUNCTIONS AFTER HERE:
   //----------------------------------------------------
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
   // parse_index parses the index of a value inside a format string. It
   // assumes that str[*local_pos] points to character after a '%' or '*', and
   // returns 0 if there is no closing $, or if it finds no number. If it finds a
   // number, it will move local_pos past the end of the $, else it will not move
   // local_pos.
   size_t parse_index(size_t *local_pos);
 
#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
   void args_to_index(size_t index);
 
   // get_type_desc assumes that this format string uses index mode. It iterates
   // through the format string until it finds a format specifier that defines
   // the type of index, and returns a TypeDesc describing that type. It does not
   // modify cur_pos.
   TypeDesc get_type_desc(size_t index);
 
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 };
 
 } // namespace printf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PARSER_H

libc/src/stdio/printf_core/parser.cpp

 //===-- Format string parser implementation 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
 //
 //===----------------------------------------------------------------------===//
 
-// #define LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE 1 // This will be a compile flag.
+// #define LIBC_COPT_PRINTF_DISABLE_INDEX_MODE 1 // This will be a compile flag.
 
 #include "parser.h"
 
 #include "src/__support/arg_list.h"
 
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_integer.h"
 #include "src/stdio/printf_core/core_structs.h"
 
 namespace __llvm_libc {
 namespace printf_core {
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 #define GET_ARG_VAL_SIMPLEST(arg_type, index) get_arg_value<arg_type>(index)
 #else
 #define GET_ARG_VAL_SIMPLEST(arg_type, _) get_next_arg_value<arg_type>()
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 FormatSection Parser::get_next_section() {
   FormatSection section;
   size_t starting_pos = cur_pos;
   if (str[cur_pos] == '%') {
     // format section
     section.has_conv = true;
 
     ++cur_pos;
     [[maybe_unused]] size_t conv_index = 0;
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
     conv_index = parse_index(&cur_pos);
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
     section.flags = parse_flags(&cur_pos);
 
     // handle width
     section.min_width = 0;
     if (str[cur_pos] == '*') {
       ++cur_pos;
 
case ('u'):
       case (LengthModifier::z):
         section.conv_val_raw = GET_ARG_VAL_SIMPLEST(size_t, conv_index);
         break;
       case (LengthModifier::t):
         section.conv_val_raw = GET_ARG_VAL_SIMPLEST(ptrdiff_t, conv_index);
         break;
       }
       break;
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
     case ('f'):
     case ('F'):
     case ('e'):
     case ('E'):
     case ('a'):
     case ('A'):
     case ('g'):
     case ('G'):
       if (lm != LengthModifier::L)
         section.conv_val_raw =
             cpp::bit_cast<uint64_t>(GET_ARG_VAL_SIMPLEST(double, conv_index));
       else
         section.conv_val_raw =
             cpp::bit_cast<fputil::FPBits<long double>::UIntType>(
                 GET_ARG_VAL_SIMPLEST(long double, conv_index));
       break;
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
-#ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
     case ('n'):
-#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
     case ('p'):
     case ('s'):
       section.conv_val_ptr = GET_ARG_VAL_SIMPLEST(void *, conv_index);
       break;
     default:
       // if the conversion is undefined, change this to a raw section.
       section.has_conv = false;
       break;
default:
     return LengthModifier::none;
   }
 }
 
 //----------------------------------------------------
 // INDEX MODE ONLY FUNCTIONS AFTER HERE:
 //----------------------------------------------------
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 size_t Parser::parse_index(size_t *local_pos) {
   if (internal::isdigit(str[*local_pos])) {
     auto result = internal::strtointeger<int>(str + *local_pos, 10);
     size_t index = result.value;
     if (str[*local_pos + result.parsed_len] != '$')
       return 0;
     *local_pos = 1 + result.parsed_len + *local_pos;
if (str[local_pos] == '%') {
         case (LengthModifier::z):
           conv_size = type_desc_from_type<size_t>();
           break;
         case (LengthModifier::t):
           conv_size = type_desc_from_type<ptrdiff_t>();
           break;
         }
         break;
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
       case ('f'):
       case ('F'):
       case ('e'):
       case ('E'):
       case ('a'):
       case ('A'):
       case ('g'):
       case ('G'):
         if (lm != LengthModifier::L)
           conv_size = type_desc_from_type<double>();
         else
           conv_size = type_desc_from_type<long double>();
         break;
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
-#ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
       case ('n'):
-#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
       case ('p'):
       case ('s'):
         conv_size = type_desc_from_type<void *>();
         break;
       default:
         conv_size = type_desc_from_type<int>();
         break;
       }
while (args_index < index) {
 
     if (cur_type_desc == type_desc_from_type<void>())
       cur_type_desc = get_type_desc(args_index);
 
     if (cur_type_desc == type_desc_from_type<uint32_t>())
       args_cur.next_var<uint32_t>();
     else if (cur_type_desc == type_desc_from_type<uint64_t>())
       args_cur.next_var<uint64_t>();
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
     // Floating point numbers are stored separately from the other arguments.
     else if (cur_type_desc == type_desc_from_type<double>())
       args_cur.next_var<double>();
     else if (cur_type_desc == type_desc_from_type<long double>())
       args_cur.next_var<long double>();
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
     // pointers may be stored separately from normal values.
     else if (cur_type_desc == type_desc_from_type<void *>())
       args_cur.next_var<void *>();
     else
       args_cur.next_var<uint32_t>();
 
     ++args_index;
   }
 }
 
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 } // namespace printf_core
 } // namespace __llvm_libc

libc/src/stdio/printf_core/printf_config.h

 // and all of the arguments before the new index must be requested with the
 // correct types. The index array caches the types of the values in the arg
 // list. For every number between the last index cached in the array and the
 // requested index, the format string must be parsed again to find the
 // type of that index. As an example, if the format string has 20 indexes, and
 // the index array is 10, then when the 20th index is requested the first 10
 // types can be found immediately, and then the format string must be parsed 10
 // times to find the types of the next 10 arguments.
-#ifndef LLVM_LIBC_PRINTF_INDEX_ARR_LEN
-#define LLVM_LIBC_PRINTF_INDEX_ARR_LEN 128
+#ifndef LIBC_COPT_PRINTF_INDEX_ARR_LEN
+#define LIBC_COPT_PRINTF_INDEX_ARR_LEN 128
 #endif
 
 // TODO(michaelrj): Move the other printf configuration options into this file.
 
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_PRINTF_CONFIG_H

libc/src/stdio/scanf_core/converter.cpp

 //===-- Format specifier converter implmentation for scanf -----*- 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/scanf_core/converter.h"
 
 #include "src/__support/ctype_utils.h"
 #include "src/stdio/scanf_core/core_structs.h"
 #include "src/stdio/scanf_core/reader.h"
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_FLOAT
+#ifndef LIBC_COPT_SCANF_DISABLE_FLOAT
 #include "src/stdio/scanf_core/float_converter.h"
-#endif // LLVM_LIBC_SCANF_DISABLE_FLOAT
+#endif // LIBC_COPT_SCANF_DISABLE_FLOAT
 #include "src/stdio/scanf_core/current_pos_converter.h"
 #include "src/stdio/scanf_core/int_converter.h"
 #include "src/stdio/scanf_core/ptr_converter.h"
 #include "src/stdio/scanf_core/string_converter.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
int convert(Reader *reader, const FormatSection &to_conv) {
   case 'u':
   case 'o':
   case 'x':
   case 'X':
     ret_val = raw_match(reader, " ");
     if (ret_val != READ_OK)
       return ret_val;
     return convert_int(reader, to_conv);
-#ifndef LLVM_LIBC_SCANF_DISABLE_FLOAT
+#ifndef LIBC_COPT_SCANF_DISABLE_FLOAT
   case 'f':
   case 'F':
   case 'e':
   case 'E':
   case 'a':
   case 'A':
   case 'g':
   case 'G':
     ret_val = raw_match(reader, " ");
     if (ret_val != READ_OK)
       return ret_val;
     return convert_float(reader, to_conv);
-#endif // LLVM_LIBC_SCANF_DISABLE_FLOAT
+#endif // LIBC_COPT_SCANF_DISABLE_FLOAT
   case 'n':
     return convert_current_pos(reader, to_conv);
   case 'p':
     ret_val = raw_match(reader, " ");
     if (ret_val != READ_OK)
       return ret_val;
     return convert_pointer(reader, to_conv);
   default:

libc/src/stdio/scanf_core/parser.h

 namespace scanf_core {
 
 class Parser {
   const char *__restrict str;
 
   size_t cur_pos = 0;
   internal::ArgList args_cur;
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
   // args_start stores the start of the va_args, which is used when a previous
   // argument is needed. In that case, we have to read the arguments from the
   // beginning since they don't support reading backwards.
   internal::ArgList args_start;
   size_t args_index = 1;
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 public:
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
   LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args), args_start(args) {}
 #else
   LIBC_INLINE Parser(const char *__restrict new_str, internal::ArgList &args)
       : str(new_str), args_cur(args) {}
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
   // get_next_section will parse the format string until it has a fully
   // specified format section. This can either be a raw format section with no
   // conversion, or a format section with a conversion that has all of its
   // variables stored in the format section.
   FormatSection get_next_section();
 
 private:
   // parse_length_modifier parses the length modifier inside a format string. It
   // assumes that str[*local_pos] is inside a format specifier. It returns a
   // LengthModifier with the length modifier it found. It will advance local_pos
   // after the format specifier if one is found.
   LengthModifier parse_length_modifier(size_t *local_pos);
 
   // get_next_arg_value gets the next value from the arg list as type T.
   template <class T> LIBC_INLINE T get_next_arg_value() {
     return args_cur.next_var<T>();
   }
 
   //----------------------------------------------------
   // INDEX MODE ONLY FUNCTIONS AFTER HERE:
   //----------------------------------------------------
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
   // parse_index parses the index of a value inside a format string. It
   // assumes that str[*local_pos] points to character after a '%' or '*', and
   // returns 0 if there is no closing $, or if it finds no number. If it finds a
   // number, it will move local_pos past the end of the $, else it will not move
   // local_pos.
   size_t parse_index(size_t *local_pos);
 
#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
   // the ArgList can only return the next item in the list. This function is
   // used in index mode when the item that needs to be read is not the next one.
   // It moves cur_args to the index requested so the the appropriate value may
   // be read. This may involve parsing the format string, and is in the worst
   // case an O(n^2) operation.
   void args_to_index(size_t index);
 
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 };
 
 } // namespace scanf_core
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_PARSER_H

libc/src/stdio/scanf_core/parser.cpp

 //===-- Format string parser implementation for scanf ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-// #define LLVM_LIBC_SCANF_DISABLE_INDEX_MODE 1 // This will be a compile flag.
+// #define LIBC_COPT_SCANF_DISABLE_INDEX_MODE 1 // This will be a compile flag.
 
 #include "src/stdio/scanf_core/parser.h"
 
 #include "src/__support/arg_list.h"
 
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/bitset.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_integer.h"
 
 namespace __llvm_libc {
 namespace scanf_core {
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 #define GET_ARG_VAL_SIMPLEST(arg_type, index) get_arg_value<arg_type>(index)
 #else
 #define GET_ARG_VAL_SIMPLEST(arg_type, _) get_next_arg_value<arg_type>()
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 FormatSection Parser::get_next_section() {
   FormatSection section;
   size_t starting_pos = cur_pos;
   if (str[cur_pos] == '%') {
     // format section
     section.has_conv = true;
 
     ++cur_pos;
     [[maybe_unused]] size_t conv_index = 0;
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
     conv_index = parse_index(&cur_pos);
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
     if (str[cur_pos] == '*') {
       ++cur_pos;
       section.flags = FormatFlags::NO_WRITE;
     }
 
     // handle width
     section.max_width = -1;
default:
     return LengthModifier::NONE;
   }
 }
 
 //----------------------------------------------------
 // INDEX MODE ONLY FUNCTIONS AFTER HERE:
 //----------------------------------------------------
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 size_t Parser::parse_index(size_t *local_pos) {
   if (internal::isdigit(str[*local_pos])) {
     auto result = internal::strtointeger<int>(str + *local_pos, 10);
     size_t index = result.value;
     if (str[*local_pos + result.parsed_len] != '$')
       return 0;
     *local_pos = 1 + result.parsed_len + *local_pos;
void Parser::args_to_index(size_t index) {
   while (args_index < index) {
     // Since all arguments must be pointers, we can just read all of them as
     // void * and not worry about type issues.
     args_cur.next_var<void *>();
     ++args_index;
   }
 }
 
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/scanf_config.h

 //===-- Scanf Configuration Handler ----------------------------*- 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_SCANF_CORE_SCANF_CONFIG_H
 #define LLVM_LIBC_SRC_STDIO_SCANF_CORE_SCANF_CONFIG_H
 
 // These macros can be set or unset to adjust scanf behavior at compile time.
 
 // This flag disables all functionality relating to floating point numbers. This
 // can be useful for embedded systems or other situations where binary size is
 // important.
-// #define LLVM_LIBC_SCANF_DISABLE_FLOAT
+// #define LIBC_COPT_SCANF_DISABLE_FLOAT
 
 // This flag disables index mode, a posix extension often used for
 // internationalization of format strings. Supporting it takes up additional
 // memory and parsing time, so it can be disabled if it's not used.
-// #define LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+// #define LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 #endif // LLVM_LIBC_SRC_STDIO_SCANF_CORE_SCANF_CONFIG_H

libc/src/stdlib/atexit.cpp

 
 struct AtExitUnit {
   AtExitCallback *callback = nullptr;
   void *payload = nullptr;
   constexpr AtExitUnit() = default;
   constexpr AtExitUnit(AtExitCallback *c, void *p) : callback(c), payload(p) {}
 };
 
-#ifdef LLVM_LIBC_PUBLIC_PACKAGING
+#ifdef LIBC_COPT_PUBLIC_PACKAGING
 using ExitCallbackList = cpp::ReverseOrderBlockStore<AtExitUnit, 32>;
 #else
 // BlockStore uses dynamic memory allocation. To avoid dynamic memory
 // allocation in tests, we use a fixed size callback list when built for
 // tests.
 // If we use BlockStore, then we will have to pull in malloc etc into
 // the tests. While this is not bad, the problem we have currently is
 // that LLVM libc' allocator is SCUDO. So, we will end up pulling SCUDO's
 // deps also (some of which are not yet available in LLVM libc) into the
 // integration tests.
 using ExitCallbackList = FixedVector<AtExitUnit, CALLBACK_LIST_SIZE_FOR_TESTS>;
-#endif // LLVM_LIBC_PUBLIC_PACKAGING
+#endif // LIBC_COPT_PUBLIC_PACKAGING
 
 constinit ExitCallbackList exit_callbacks;
 
 void stdc_at_exit_func(void *payload) {
   reinterpret_cast<StdCAtExitCallback *>(payload)();
 }
 
 } // namespace

libc/src/string/string_utils.h

LIBC_INLINE size_t string_length_byte_read(const char *src) {
   for (length = 0; *src; ++src, ++length)
     ;
   return length;
 }
 
 // Returns the length of a string, denoted by the first occurrence
 // of a null terminator.
 LIBC_INLINE size_t string_length(const char *src) {
-#ifdef LIBC_UNSAFE_STRING_WIDE_READ
+#ifdef LIBC_COPT_UNSAFE_STRING_WIDE_READ
   // Unsigned int is the default size for most processors, and on x86-64 it
   // performs better than larger sizes when the src pointer can't be assumed to
   // be aligned to a word boundary, so it's the size we use for reading the
   // string a block at a time.
   return string_length_wide_read<unsigned int>(src);
 #else
   return string_length_byte_read(src);
 #endif
for (; n && *src != ch; --n, ++src)
     ;
   return n ? const_cast<unsigned char *>(src) : nullptr;
 }
 
 // Returns the first occurrence of 'ch' within the first 'n' characters of
 // 'src'. If 'ch' is not found, returns nullptr.
 LIBC_INLINE void *find_first_character(const unsigned char *src,
                                        unsigned char ch, size_t max_strlen) {
-#ifdef LIBC_UNSAFE_STRING_WIDE_READ
+#ifdef LIBC_COPT_UNSAFE_STRING_WIDE_READ
   // If the maximum size of the string is small, the overhead of aligning to a
   // word boundary and generating a bitmask of the appropriate size may be
   // greater than the gains from reading larger chunks. Based on some testing,
   // the crossover point between when it's faster to just read bytewise and read
   // blocks is somewhere between 16 and 32, so 4 times the size of the block
   // should be in that range.
   // Unsigned int is used for the same reason as in strlen.
   using BlockType = unsigned int;

libc/src/unistd/getopt.cpp

 
 static unsigned optpos;
 
 static GetoptContext ctx{
     &impl::optarg, &impl::optind,
     &impl::optopt, &optpos,
     impl::opterr,  reinterpret_cast<FILE *>(__llvm_libc::stderr)};
 
-#ifndef LLVM_LIBC_PUBLIC_PACKAGING
+#ifndef LIBC_COPT_PUBLIC_PACKAGING
 // This is used exclusively in tests.
 void set_getopt_state(char **optarg, int *optind, int *optopt, unsigned *optpos,
                       int opterr, FILE *errstream) {
   ctx = {optarg, optind, optopt, optpos, opterr, errstream};
 }
 #endif
 
 } // namespace impl
 
 LLVM_LIBC_FUNCTION(int, getopt,
                    (int argc, char *const argv[], const char *optstring)) {
   return getopt_r(argc, argv, optstring, impl::ctx);
 }
 
 } // namespace __llvm_libc

libc/test/UnitTest/FPExceptMatcher.h

 //===-- FPExceptMatcher.h ---------------------------------------*- 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_FPEXCEPTMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPEXCEPTMATCHER_H
 
-#ifndef LLVM_LIBC_TEST_USE_FUCHSIA
+#ifndef LIBC_COPT_TEST_USE_FUCHSIA
 
 #include "test/UnitTest/Test.h"
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 // TODO: Make the matcher match specific exceptions instead of just identifying

 #define ASSERT_RAISES_FP_EXCEPT(func)                                          \
   ASSERT_THAT(                                                                 \
       true,                                                                    \
       __llvm_libc::fputil::testing::FPExceptMatcher(                           \
           __llvm_libc::fputil::testing::FPExceptMatcher::getFunctionCaller(    \
               func)))
 #else
 #define ASSERT_RAISES_FP_EXCEPT(func) ASSERT_DEATH(func, WITH_SIGNAL(SIGFPE))
-#endif // LLVM_LIBC_TEST_USE_FUCHSIA
+#endif // LIBC_COPT_TEST_USE_FUCHSIA
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_FPEXCEPTMATCHER_H

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
 
-#ifdef LLVM_LIBC_TEST_USE_FUCHSIA
+#ifdef LIBC_COPT_TEST_USE_FUCHSIA
 #include "FuchsiaTest.h"
 #else
 #include "LibcTest.h"
 #endif
 
 #endif // LLVM_LIBC_UTILS_UNITTEST_TEST_H

libc/test/src/math/RoundToIntegerTest.h

if (math_errhandling & MATH_ERREXCEPT) {
       // if the appropriate flag was raised.
       __llvm_libc::fputil::disable_except(FE_ALL_EXCEPT);
     }
   }
 
   void do_infinity_and_na_n_test(RoundToIntegerFunc func) {
     test_one_input(func, inf, INTEGER_MAX, true);
     test_one_input(func, neg_inf, INTEGER_MIN, true);
-#if LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR
+    // This is currently never enabled, the
+    // LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR CMake option in
+    // libc/CMakeLists.txt is not forwarded to C++.
+#if LIBC_COPT_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR
     // Result is not well-defined, we always returns INTEGER_MAX
     test_one_input(func, nan, INTEGER_MAX, true);
-#endif
+#endif // LIBC_COPT_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR
   }
 
   void testInfinityAndNaN(RoundToIntegerFunc func) {
     if (TestModes) {
       for (int mode : ROUNDING_MODES) {
         __llvm_libc::fputil::set_round(mode);
         do_infinity_and_na_n_test(func);
       }

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

TEST(LlvmLibcPrintfParserTest, EvalThreeArgs) {
 
   expected2.raw_string = {str + 4, 2};
   expected2.conv_val_ptr = const_cast<char *>(arg3);
   expected2.conv_name = 's';
 
   ASSERT_PFORMAT_EQ(expected2, format_arr[2]);
 }
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_PRINTF_DISABLE_INDEX_MODE
 
 TEST(LlvmLibcPrintfParserTest, IndexModeOneArg) {
   __llvm_libc::printf_core::FormatSection format_arr[10];
   const char *str = "%1$d";
   int arg1 = 12345;
   evaluate(format_arr, str, arg1);
 
   __llvm_libc::printf_core::FormatSection expected;
TEST(LlvmLibcPrintfParserTest, IndexModeComplexParsing) {
   expected9.min_width = 1;
   expected9.precision = 1;
   expected9.conv_val_raw = arg1;
   expected9.conv_name = 'c';
 
   EXPECT_PFORMAT_EQ(expected9, format_arr[9]);
 }
 
-#endif // LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE

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

TEST(LlvmLibcScanfParserTest, EvalThreeArgs) {
 
   expected2.raw_string = {str + 4, 2};
   expected2.output_ptr = &arg3;
   expected2.conv_name = 's';
 
   ASSERT_SFORMAT_EQ(expected2, format_arr[2]);
 }
 
-#ifndef LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_SCANF_DISABLE_INDEX_MODE
 
 TEST(LlvmLibcScanfParserTest, IndexModeOneArg) {
   __llvm_libc::scanf_core::FormatSection format_arr[10];
   const char *str = "%1$d";
   int arg1 = 12345;
   evaluate(format_arr, str, &arg1);
 
   __llvm_libc::scanf_core::FormatSection expected;
TEST(LlvmLibcScanfParserTest, IndexModeComplexParsing) {
 
   scan_set.set_range('1', '3');
 
   expected10.scan_set = scan_set;
 
   EXPECT_SFORMAT_EQ(expected10, format_arr[10]);
 }
 
-#endif // LLVM_LIBC_SCANF_DISABLE_INDEX_MODE
+#endif // LIBC_COPT_SCANF_DISABLE_INDEX_MODE

libc/test/src/stdio/sprintf_test.cpp

TEST(LlvmLibcSPrintfTest, OctConv) {
   ASSERT_STREQ(buff, "0075 0025");
 
   written = __llvm_libc::sprintf(buff, "%04hho %#.5llo %-6.3zo", 256 + 077,
                                  01000000000000ll, size_t(2));
   EXPECT_EQ(written, 26);
   ASSERT_STREQ(buff, "0077 01000000000000 002   ");
 }
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#ifndef LIBC_COPT_PRINTF_DISABLE_FLOAT
 
 TEST_F(LlvmLibcSPrintfTest, FloatHexExpConv) {
   __llvm_libc::testutils::ForceRoundingMode r(
       __llvm_libc::testutils::RoundingMode::Nearest);
   double inf = __llvm_libc::fputil::FPBits<double>::inf().get_val();
   double nan = __llvm_libc::fputil::FPBits<double>::build_nan(1);
 
   written = __llvm_libc::sprintf(buff, "%a", 1.0);
*/
 
   written = __llvm_libc::sprintf(buff, "%#12.3g %-12.3g", 0.1, 256.0);
   ASSERT_STREQ_LEN(written, buff, "       0.100 256         ");
 
   written = __llvm_libc::sprintf(buff, "%+-#12.3g % 012.3g", 0.1256, 1256.0);
   ASSERT_STREQ_LEN(written, buff, "+0.126        0001.26e+03");
 }
 
-#endif // LLVM_LIBC_PRINTF_DISABLE_FLOAT
+#endif // LIBC_COPT_PRINTF_DISABLE_FLOAT
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
 TEST(LlvmLibcSPrintfTest, WriteIntConv) {
   char buff[64];
   int written;
   int test_val = -1;
 
   test_val = -1;
   written = __llvm_libc::sprintf(buff, "12345%n67890", &test_val);
   EXPECT_EQ(written, 10);
TEST(LlvmLibcSPrintfTest, WriteIntConv) {
   written = __llvm_libc::sprintf(buff, "%s%n", "87654321", &test_val);
   EXPECT_EQ(written, 8);
   EXPECT_EQ(test_val, 8);
   ASSERT_STREQ(buff, "87654321");
 
   written = __llvm_libc::sprintf(buff, "abc123%n", nullptr);
   EXPECT_LT(written, 0);
 }
-#endif // LLVM_LIBC_PRINTF_DISABLE_WRITE_INT
+#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
 
-#ifndef LLVM_LIBC_PRINTF_DISABLE_INDEX_MODE
+#ifndef LIBC_COPT_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
+#endif // LIBC_COPT_PRINTF_DISABLE_INDEX_MODE

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

native.cc_library(
         **kwargs
     )
 
     # This second target is the llvm libc C function.
 
     func_attrs = ["__attribute__((visibility(\"default\")))"]
     if weak:
         func_attrs.append("__attribute__((weak))")
-    local_defines = local_defines or ["LLVM_LIBC_PUBLIC_PACKAGING"]
+    local_defines = local_defines or ["LIBC_COPT_PUBLIC_PACKAGING"]
     local_defines.append("LLVM_LIBC_FUNCTION_ATTR='%s'" % " ".join(func_attrs))
     _libc_library(
         name = name,
         srcs = srcs,
         deps = deps,
         copts = copts,
         local_defines = local_defines,
         **kwargs