[libc] Introduce a libc internal assertion macro named LIBC_ASSERT.

[sivachandra]

Summary

Few existing call-sites have been modified to use LIBC_ASSERT.

[lntue]

libc/src/__support/float_to_string.h

67

I don't see anywhere in the LIBC_ASSERT definition that can take the error message. Also, this is && with the conditions in the previous line?

[sivachandra]

libc/src/__support/float_to_string.h

67

That is just the conventional way to attach messages to asserts: https://stackoverflow.com/questions/5867834/assert-with-message
But, I am OK with adding a real message argument to the macro, which is probably nicer?

[sivachandra]

libc/src/__support/float_to_string.h

67

FWIW, there are many many examples of such uses with plain assert in LLVM. Example: https://github.com/llvm/llvm-project/blob/main/llvm/lib/Analysis/AssumptionCache.cpp#L175

[lntue]

libc/src/__support/float_to_string.h

67

Thanks, I see how the message is printed. It basically comes together with the whole condition in #COND

[michaelrj]

LGTM

libc/src/__support/CMakeLists.txt

 add_subdirectory(CPP)
 add_subdirectory(macros)
 
 add_header_library(
   blockstore
   HDRS
     blockstore.h
   DEPENDS
+    .libc_assert
     libc.src.__support.CPP.new
 )
 
 add_header_library(
   named_pair
   HDRS
     named_pair.h
 )

 
 
 add_header_library(
   float_to_string
   HDRS
     float_to_string.h
     ryu_constants.h
   DEPENDS
+    .libc_assert
     libc.src.__support.CPP.type_traits
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.common
 )
 
 add_header_library(
   high_precision_decimal
   HDRS

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

libc/src/__support/blockstore.h

 //===-- A data structure which stores data in blocks  -----------*- 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_SUPPORT_BLOCKSTORE_H
 #define LLVM_LIBC_SUPPORT_BLOCKSTORE_H
 
 #include <src/__support/CPP/new.h>
+#include <src/__support/libc_assert.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
-// TODO: fix our assert.h to make it useable
-#define assert(x)                                                              \
-  if (!(x))                                                                    \
-  __builtin_trap()
-
 namespace __llvm_libc {
 namespace cpp {
 
 // The difference between BlockStore a traditional vector types is that,
 // when more capacity is desired, a new block is added instead of allocating
 // a larger sized array and copying over existing items to the new allocation.
 // Also, the initial block does not need heap allocation. Hence, a BlockStore is
 // suitable for global objects as it does not require explicit construction.
protected:
   };
   Pair getLastBlocks() {
     if (REVERSE_ORDER)
       return {current, current->next};
     Block *prev = nullptr;
     Block *curr = &first;
     for (; curr->next; prev = curr, curr = curr->next)
       ;
-    assert(curr == current);
+    LIBC_ASSERT(curr == current);
     return {curr, prev};
   }
 
   Block *getLastBlock() { return getLastBlocks().first; }
 
 public:
   constexpr BlockStore() = default;
   ~BlockStore() = default;
public:
   }
 
   void pop_back() {
     fill_count--;
     if (fill_count || current == &first)
       return;
     auto [last, prev] = getLastBlocks();
     if (REVERSE_ORDER) {
-      assert(last == current);
+      LIBC_ASSERT(last == current);
       current = current->next;
     } else {
-      assert(prev->next == last);
+      LIBC_ASSERT(prev->next == last);
       current = prev;
       current->next = nullptr;
     }
     if (last != &first)
       delete last;
     fill_count = BLOCK_SIZE;
   }
 

libc/src/__support/float_to_string.h

 #define LLVM_LIBC_SRC_SUPPORT_FLOAT_TO_STRING_H
 
 #include <stdint.h>
 
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/UInt.h"
 #include "src/__support/common.h"
+#include "src/__support/libc_assert.h"
 #include "src/__support/ryu_constants.h"
 
 // This implementation is based on the Ryu Printf algorithm by Ulf Adams:
 // Ulf Adams. 2019. Ryū revisited: printf floating point conversion.
 // Proc. ACM Program. Lang. 3, OOPSLA, Article 169 (October 2019), 23 pages.
 // https://doi.org/10.1145/3360595
 
 // This version is modified to require significantly less memory (it doesn't use

 
 constexpr size_t MID_INT_SIZE = 192;
 
 namespace internal {
 
 // Returns floor(log_10(2^e)); requires 0 <= e <= 1650.
 LIBC_INLINE constexpr uint32_t log10_pow2(const uint32_t e) {
   // The first value this approximation fails for is 2^1651 which is just
-  // greater than 10^297. assert(e >= 0); assert(e <= 1650);
+  // greater than 10^297.
+  LIBC_ASSERT(e >= 0 && e <= 1650 &&
+              "Incorrect exponent to perform log10_pow2 approximation.");
   return (e * 78913) >> 18;
 }
 
 // Returns 1 + floor(log_10(2^e). This could technically be off by 1 if any
 // power of 2 was also a power of 10, but since that doesn't exist this is
 // always accurate. This is used to calculate the maximum number of base-10
 // digits a given e-bit number could have.
 LIBC_INLINE constexpr uint32_t ceil_log10_pow2(const uint32_t e) {

libc/src/__support/libc_assert.h

+//===-- Definition of a libc internal assert macro --------------*- 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_LIBC_ASSERT_H
+#define LLVM_LIBC_SRC_SUPPORT_LIBC_ASSERT_H
+
+#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>()];
+  IntegerToString::dec(line, line_str);
+  __llvm_libc::write_to_stderr(filename);
+  __llvm_libc::write_to_stderr(":");
+  __llvm_libc::write_to_stderr(line_str);
+  __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 intenral 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
+#define LIBC_ASSERT(COND)                                                      \
+  do {                                                                         \
+    if (!(COND)) {                                                             \
+      __llvm_libc::report_assertion_failure(#COND, __FILE__, __LINE__,         \
+                                            __PRETTY_FUNCTION__);              \
+      __llvm_libc::quick_exit(0xFF);                                           \
+    }                                                                          \
+  } while (false)
+#endif // NDEBUG
+
+#endif // LLVM_LIBC_SRC_SUPPORT_LIBC_ASSERT_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/__support/OSUtil/io.h"
 #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)) {
-  (void)line; // Suppress warning as long as line is unused.
-  write_to_stderr(file);
-  write_to_stderr(": Assertion failed: '");
-  write_to_stderr(assertion);
-  write_to_stderr("' in function: '");
-  write_to_stderr(function);
-  write_to_stderr("'\n");
+  __llvm_libc::report_assertion_failure(assertion, file, line, function);
   __llvm_libc::abort();
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/CMakeLists.txt

DEPENDS
     .writer
     .core_structs
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.FPUtil.fp_bits
     libc.src.__support.FPUtil.fenv_impl
     libc.src.__support.common
+    libc.src.__support.libc_assert
     libc.src.__support.uint
     libc.src.__support.uint128
     libc.src.__support.integer_to_string
     libc.src.__support.float_to_string
 )
 
 
 add_object_library(

libc/src/stdio/printf_core/float_dec_converter.h

 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/FloatProperties.h"
 #include "src/__support/UInt.h"
 #include "src/__support/UInt128.h"
 #include "src/__support/common.h"
 #include "src/__support/float_to_string.h"
 #include "src/__support/integer_to_string.h"
+#include "src/__support/libc_assert.h"
 #include "src/stdio/printf_core/converter_utils.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/float_inf_nan_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
if (round == RoundDirection::Up) {
     round_up = false;
   } else {
     // RoundDirection is even, so check the extra digit.
     uint32_t low_digit = digits % 10;
     round_up = (low_digit % 2) != 0;
   }
 
   digits_checked += digits_requested;
-  // assert(digits_checked == init_precision);
+  LIBC_ASSERT(digits_checked == init_precision);
   // At this point we should have checked all the digits requested by the
   // precision. We may increment this number 1 more if we round up all of the
   // digits, but at this point in the code digits_checked should always equal
   // init_precision.
 
   if (round_up) {
     // If all the digits that would be printed are nines, then rounding up means
     // that the base 10 exponent is one higher and all those nines turn to