[libc][NFC] Simplify assert message generation

[michaelrj]

Summary

Previously displaying a failed assert would involve a runtime integer to
string conversion. This patch changes that to be a compile time string
conversion.

This was inspired by a comment by JonChesterfield on https://reviews.llvm.org/D155899

[JonChesterfield]

LGTM. I'm slightly surprised __PRETTY_FUNCTION__ can't be concatenated with string literals at preprocessor time but I'm getting errors when I try it.

This might leak into user code. Is there an existing __LIBC_ prefix or similar?

Thanks for dropping the runtime int -> string conversion, always pleased to have fewer things that can go wrong at runtime.

[michaelrj]

I'm also kinda confused why __PRETTY_FUNCTION__ isn't available to the preprocessor, maybe it's to do with C++ mangling semantics?

I'll look into better names for the macros, I think something like __LIBC would probably work.

Yeah, my first try involved constexpr strings that were concatenated at compile time, but then I realized that the macros are just strings themselves (or close enough with line).

[sivachandra]

libc/src/__support/libc_assert.h

27–28

With this change I think it is better to inline these calls also in the macro below. The format relation ship between error_str and funcname is decided in that macro so keep it there.

[michaelrj]

add a prefix to the macros and inline the write_to_stderr calls.

[mcgrathr]

libc/src/__support/libc_assert.h

57

even if it's not a pastable string literal, it should be possible to do constexpr stuff to turn this into a single string constant for a single write call

libc/src/__support/libc_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/macros/attributes.h" // For LIBC_INLINE
 
-namespace __llvm_libc {
-
-LIBC_INLINE void report_assertion_failure(const char *assertion,
-                                          const char *filename, unsigned line,
-                                          const char *funcname) {
-  char line_str[IntegerToString::dec_bufsize<unsigned>()];
-  // dec returns an optional, will always be valid for this size buffer
-  auto line_number = IntegerToString::dec(line, line_str);
-  __llvm_libc::write_to_stderr(filename);
-  __llvm_libc::write_to_stderr(":");
-  __llvm_libc::write_to_stderr(*line_number);
-  __llvm_libc::write_to_stderr(": Assertion failed: '");
-  __llvm_libc::write_to_stderr(assertion);
-  __llvm_libc::write_to_stderr("' in function: '");
-  __llvm_libc::write_to_stderr(funcname);
-  __llvm_libc::write_to_stderr("'\n");
-}
-
-} // namespace __llvm_libc
-
 #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::report_assertion_failure(#COND, __FILE__, __LINE__,         \
-                                            __PRETTY_FUNCTION__);              \
+      __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");                                     \
       __llvm_libc::quick_exit(0xFF);                                           \
     }                                                                          \
   } while (false)
 #endif // NDEBUG
 
 #endif // LIBC_COPT_USE_C_ASSERT
 
 #endif // LLVM_LIBC_SRC_SUPPORT_LIBC_ASSERT_H