[libc] Move public assert to macro printing

[michaelrj]

Summary

The previous assert patch only changed the internal LIBC_ASSERT macro.
The public assert function also needs to be moved since the previous
printing method was removed. This patch refactors the display code into
a separate file so that it can safely be included by external code. This
isn't ideal, but passing the macros to functions turns them from literal
strings to char*s, requiring manual concatenation.

[michaelrj]

Delaying landing this patch since I discovered that assert is one of the last macros still in headergen. I need to do more digging to sort that out.

libc/src/__support/CMakeLists.txt

add_header_library(
   uint128
   HDRS
     UInt128.h
   DEPENDS
     .uint
 )
 
 add_header_library(
+  display_assert
+  HDRS
+    display_assert.h
+  DEPENDS
+    libc.src.__support.OSUtil.osutil
+)
+
+add_header_library(
   libc_assert
   HDRS
     libc_assert.h
   DEPENDS
-    .integer_to_string
+    .display_assert
     libc.src.__support.OSUtil.osutil
 )
 
 add_subdirectory(FPUtil)
 add_subdirectory(OSUtil)
 add_subdirectory(StringUtil)
 add_subdirectory(GPU)
 add_subdirectory(RPC)
 
 # Thread support is used by other "File". So, we add the "threads"
 # before "File".
 add_subdirectory(threads)
 
 add_subdirectory(File)

libc/src/__support/display_assert.h

+//===-- Display macro for assertion fail ------------------------*- 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_SUPPORT_DISPLAY_ASSERT_H
+#define LLVM_LIBC_SRC_SUPPORT_DISPLAY_ASSERT_H
+
+#include "src/__support/OSUtil/io.h"
+
+// Convert __LINE__ to a string using macros. The indirection is necessary
+// because otherwise it will turn "__LINE__" into a string, not its value. The
+// value is evaluated in the indirection step.
+#define __LIBC_MACRO_TO_STR(x) #x
+#define __LIBC_MACRO_TO_STR_INDIR(y) __LIBC_MACRO_TO_STR(y)
+#define __LIBC_LINE_STR__ __LIBC_MACRO_TO_STR_INDIR(__LINE__)
+
+// This is in parentheses and commas so that the ternary operator in the assert
+// macro works.
+#define LIBC_DISPLAY_ASSERT(COND)                                              \
+  (__llvm_libc::write_to_stderr(__FILE__ ":" __LIBC_LINE_STR__                 \
+                                         ": Assertion failed: '" #COND         \
+                                         "' in function: '"),                  \
+   __llvm_libc::write_to_stderr(__PRETTY_FUNCTION__),                          \
+   __llvm_libc::write_to_stderr("'\n"))
+
+#endif // LLVM_LIBC_SRC_SUPPORT_DISPLAY_ASSERT_H

libc/src/__support/libc_assert.h

 // for libc's internal assertions.
 
 #include <assert.h>
 
 #define LIBC_ASSERT(COND) assert(COND)
 
 #else // Not LIBC_COPT_USE_C_ASSERT
 
-#include "src/__support/OSUtil/io.h"
 #include "src/__support/OSUtil/quick_exit.h"
-#include "src/__support/integer_to_string.h"
+#include "src/__support/display_assert.h"
 #include "src/__support/macros/attributes.h" // For LIBC_INLINE
 
 #ifdef LIBC_ASSERT
 #error "Unexpected: LIBC_ASSERT macro already defined"
 #endif
 
 // The public "assert" macro calls abort on failure. Should it be same here?
 // The libc internal assert can fire from anywhere inside the libc. So, to
 // avoid potential chicken-and-egg problems, it is simple to do a quick_exit
 // on assertion failure instead of calling abort. We also don't want to use
 // __builtin_trap as it could potentially be implemented using illegal
 // instructions which can be very misleading when debugging.
 #ifdef NDEBUG
 #define LIBC_ASSERT(COND)                                                      \
   do {                                                                         \
   } while (false)
 #else
 
-// Convert __LINE__ to a string using macros. The indirection is necessary
-// because otherwise it will turn "__LINE__" into a string, not its value. The
-// value is evaluated in the indirection step.
-#define __LIBC_MACRO_TO_STR(x) #x
-#define __LIBC_MACRO_TO_STR_INDIR(y) __LIBC_MACRO_TO_STR(y)
-#define __LIBC_LINE_STR__ __LIBC_MACRO_TO_STR_INDIR(__LINE__)
-
 #define LIBC_ASSERT(COND)                                                      \
   do {                                                                         \
     if (!(COND)) {                                                             \
-      __llvm_libc::write_to_stderr(__FILE__ ":" __LIBC_LINE_STR__              \
-                                            ": Assertion failed: '" #COND      \
-                                            "' in function: '");               \
-      __llvm_libc::write_to_stderr(__PRETTY_FUNCTION__);                       \
-      __llvm_libc::write_to_stderr("'\n");                                     \
+      LIBC_DISPLAY_ASSERT(COND);                                               \
       __llvm_libc::quick_exit(0xFF);                                           \
     }                                                                          \
   } while (false)
 #endif // NDEBUG
 
 #endif // LIBC_COPT_USE_C_ASSERT
 
 #endif // LLVM_LIBC_SRC_SUPPORT_LIBC_ASSERT_H

libc/src/assert/CMakeLists.txt

 add_entrypoint_object(
   __assert_fail
   SRCS
     __assert_fail.cpp
   HDRS
     __assert_fail.h
     assert.h
   DEPENDS
     libc.include.assert
     libc.src.__support.OSUtil.osutil
+    libc.src.__support.display_assert
     libc.src.stdlib.abort
 )

libc/src/assert/__assert_fail.h

 //===-- Internal header for __assert_fail -----------------------*- 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_ASSERT_ASSERT_FAIL_H
 #define LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
-[[noreturn]] void __assert_fail(const char *assertion, const char *file,
-                                unsigned line, const char *function);
+[[noreturn]] void __assert_fail();
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_ASSERT_ASSERT_FAIL_H

libc/src/assert/__assert_fail.cpp

 //===-- Implementation of __assert_fail -----------------------------------===//
 //
 // 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/assert/__assert_fail.h"
 #include "src/__support/OSUtil/io.h"
-#include "src/__support/libc_assert.h"
 #include "src/stdlib/abort.h"
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(void, __assert_fail,
-                   (const char *assertion, const char *file, unsigned line,
-                    const char *function)) {
-  __llvm_libc::report_assertion_failure(assertion, file, line, function);
-  __llvm_libc::abort();
-}
+LLVM_LIBC_FUNCTION(void, __assert_fail, ()) { __llvm_libc::abort(); }
 
 } // namespace __llvm_libc

libc/src/assert/assert.h

 //===-- Internal header for assert ------------------------------*- 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/__support/display_assert.h"
 #include "src/assert/__assert_fail.h"
 
 // There is no header guard here since assert is intended to be capable of being
 // included multiple times with NDEBUG defined differently, causing different
 // behavior.
 
 #undef assert
 
 #ifdef NDEBUG
 #define assert(e) (void)0
 #else
 #define assert(e)                                                              \
-  ((e) ? (void)0                                                               \
-       : __llvm_libc::__assert_fail(#e, __FILE__, __LINE__,                    \
-                                    __PRETTY_FUNCTION__))
+  ((e) ? (void)0 : LIBC_DISPLAY_ASSERT(e), __llvm_libc::__assert_fail())
 #endif

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

deps = [
         ":__support_cpp_optional",
         ":__support_cpp_span",
         ":__support_cpp_string_view",
         ":__support_cpp_type_traits",
         ":libc_root",
     ],
 )
 
+
+libc_support_library(
+    name = "__support_display_assert",
+    hdrs = ["src/__support/display_assert.h"],
+    deps = [
+        ":__support_osutil_io",
+        ":libc_root",
+    ],
+)
+
 libc_support_library(
     name = "__support_libc_assert",
     hdrs = ["src/__support/libc_assert.h"],
     deps = [
-        ":__support_integer_to_string",
         ":__support_macros_attributes",
         ":__support_osutil_io",
         ":__support_osutil_quick_exit",
+        ":__support_display_assert",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_ctype_utils",
     hdrs = ["src/__support/ctype_utils.h"],
 )