Heap: Improve debug caller address reporting

cores/esp8266/abi.cpp

@@ -20,64 +20,358 @@
 #include <assert.h>
 #include <Arduino.h>
 #include <cxxabi.h>
+#include <bits/c++config.h>
+#include <bit>
 
 using __cxxabiv1::__guard;
 
 // Debugging helper, last allocation which returned NULL
-extern void *umm_last_fail_alloc_addr;
-extern int umm_last_fail_alloc_size;
+extern "C" void* _heap_abi_malloc(size_t size, bool unhandled, const void* const caller);
+#if UMM_ENABLE_MEMALIGN
+extern "C" void* _heap_abi_memalign(size_t alignment, size_t size, bool unhandled, const void* const caller);
+#endif
 
 extern "C" void __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
 extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
 
 
-#if !defined(__cpp_exceptions)
+#if DEV_DEBUG_ABI_CPP
+extern "C" void _dbg_abi_print_pstr(const char* op, const char *function_name, const void* caller);
+#define DEBUG_NEW_OP_PRINTF() _dbg_abi_print_pstr("new_op", __PRETTY_FUNCTION__, NULL)
+#else
+#define DEBUG_NEW_OP_PRINTF() do { } while (false)
+#endif
+/*
+  This is what I perceived to be the intent of the original code.
 
-// overwrite weak operators new/new[] definitions
+  Use C++ "Replaceable allocation functions" to install debug wrappers to catch
+  additional information for debugging. The default C++ exception handlers use
+  weak links.
+
+  C++ Exceptions: "enabled" -
+    * With debug (eg. "Debug port: Serial"), do full caller info capture and
+      Heap debug checks. "Replaceable allocation functions" are in use by the
+      debugging code. "Replaceable allocation functions" are not available to
+      the Sketch.
+    * Without debug, no OOM details captured. The C++ "Replaceable allocation
+      functions" are available to the Sketch.
+
+  C++ Exceptions: "disabled" -
+    * C++ "Replaceable allocation functions" are always in use.
+    * With debug, do full caller info capture and Heap debug checks.
+    * Without debug, capture minimum OOM information. Calling address and size
+      of last alloc failure.
+*/
+
+#if defined(__cpp_exceptions) && \
+(defined(DEBUG_ESP_OOM) || defined(DEBUG_ESP_PORT) || defined(DEBUG_ESP_WITHINISR) || defined(MIN_ESP_OOM))
 
-void* operator new(size_t size)
+// Debug replacement adaptation from ".../new_op.cc".
+using std::new_handler;
+using std::bad_alloc;
+
+#if defined(UMM_ENABLE_MEMALIGN)
+
+// Includes C++ exceptions
+// Includes C++17 operator new align variants
+
+static void* _heap_new_align(std::size_t size, std::size_t alignment, const void* caller)
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
-        __unhandled_exception(PSTR("OOM"));
+    /*
+       "Alignment must be a power of two."
+       The C++ sample code did this: if (__builtin_expect(!std::__has_single_bit(alignment), false)) throw(bad_alloc());
+
+       From https://en.cppreference.com/w/cpp/memory/c/aligned_alloc
+         "alignment - specifies the alignment. Must be a valid alignment
+         supported by the implementation."
+
+       I left the validation to the umm_malloc library. See umm_memalign() for
+       details. Generally speaking, zero is handled as default, and the default
+       is sizeof(umm_block), 8 bytes. Since the default is 8 bytes, the
+       umm_malloc library is less strict about checking alignments less than 8
+       bytes.
+    */
+
+    void* p;
+
+    while (nullptr == (p = _heap_abi_memalign(alignment, size, false, caller))) {
+        new_handler handler = std::get_new_handler();
+        if (!handler) {
+            throw(bad_alloc());
+        }
+        handler();
     }
-    return ret;
+
+    return p;
+}
+
+
+// new_opa
+void* operator new (std::size_t size, std::align_val_t alignment)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new_align(size, std::size_t(alignment), __builtin_return_address(0));
+}
+
+// new_opva
+void* operator new[] (std::size_t size, std::align_val_t alignment)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new_align(size, std::size_t(alignment), __builtin_return_address(0));
 }
 
-void* operator new[](size_t size)
+// new_opant
+void* operator new (std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
-        __unhandled_exception(PSTR("OOM"));
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new_align(size, std::size_t(alignment), __builtin_return_address(0));
+    }
+    __catch(...) {
+        return nullptr;
     }
-    return ret;
 }
 
-void* operator new (size_t size, const std::nothrow_t&)
+// new_opvant
+void* operator new[] (std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new_align(size, std::size_t(alignment), __builtin_return_address(0));
+    }
+    __catch(...) {
+        return nullptr;
     }
-    return ret;
 }
 
-void* operator new[] (size_t size, const std::nothrow_t&)
+// new_op
+void* operator new (std::size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new_align(size, __STDCPP_DEFAULT_NEW_ALIGNMENT__, __builtin_return_address(0));
+}
+
+// new_opv
+void* operator new[] (std::size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new_align(size, __STDCPP_DEFAULT_NEW_ALIGNMENT__, __builtin_return_address(0));
+}
+
+// new_opnt
+void* operator new (size_t size, const std::nothrow_t&) noexcept
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new_align(size, __STDCPP_DEFAULT_NEW_ALIGNMENT__, __builtin_return_address(0));
+    }
+    __catch (...) {
+        return nullptr;
+    }
+}
+
+// new_opvnt
+void* operator new[] (size_t size, const std::nothrow_t&) noexcept
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new_align(size, __STDCPP_DEFAULT_NEW_ALIGNMENT__, __builtin_return_address(0));
+    }
+    __catch (...) {
+        return nullptr;
+    }
+}
+
+#else // ! UMM_ENABLE_MEMALIGN
+
+// Includes C++ exceptions
+// Without C++17 operator new align variants
+
+static void* _heap_new(std::size_t size, const void* caller)
+{
+    void* p;
+
+    while (nullptr == (p = _heap_abi_malloc(size, false, caller))) {
+        new_handler handler = std::get_new_handler();
+        if (!handler) {
+            throw(bad_alloc());
+        }
+        handler();
+    }
+
+    return p;
+}
+
+void* operator new (std::size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new(size, __builtin_return_address(0));
+}
+
+void* operator new[] (std::size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_new(size, __builtin_return_address(0));
+}
+
+void* operator new (size_t size, const std::nothrow_t&) noexcept
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new(size, __builtin_return_address(0));
+    }
+    __catch (...) {
+        return nullptr;
+    }
+}
+
+void* operator new[] (size_t size, const std::nothrow_t&) noexcept
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
+    DEBUG_NEW_OP_PRINTF();
+
+    __try {
+        return _heap_new(size, __builtin_return_address(0));
     }
-    return ret;
+    __catch (...) {
+        return nullptr;
+    }
+}
+#endif // #if UMM_ENABLE_MEMALIGN
+
+#elif !defined(__cpp_exceptions)
+// When doing builds with C++ Exceptions "disabled", always save details of
+// the last OOM event.
+
+// overwrite weak operators new/new[] definitions
+
+#if defined(UMM_ENABLE_MEMALIGN)
+
+// Without C++ exceptions
+// Includes C++17 operator new align variants
+
+void* operator new (size_t size, std::align_val_t alignment)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(std::size_t(alignment), size, true, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size, std::align_val_t alignment)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(std::size_t(alignment), size, true, __builtin_return_address(0));
+}
+
+void* operator new (size_t size, std::align_val_t alignment, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(std::size_t(alignment), size, false, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size, std::align_val_t alignment, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(std::size_t(alignment), size, false, __builtin_return_address(0));
+}
+
+void* operator new (size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(__STDCPP_DEFAULT_NEW_ALIGNMENT__, size, true, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(__STDCPP_DEFAULT_NEW_ALIGNMENT__, size, true, __builtin_return_address(0));
+}
+
+void* operator new (size_t size, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(__STDCPP_DEFAULT_NEW_ALIGNMENT__, size, false, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_memalign(__STDCPP_DEFAULT_NEW_ALIGNMENT__, size, false, __builtin_return_address(0));
+}
+
+#else
+
+// Without C++ exceptions
+// Without C++17 operator new align variants
+
+void* operator new (size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_malloc(size, true, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_malloc(size, true, __builtin_return_address(0));
 }
 
-#endif // !defined(__cpp_exceptions)
+void* operator new (size_t size, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_malloc(size, false, __builtin_return_address(0));
+}
+
+void* operator new[] (size_t size, const std::nothrow_t&)
+{
+    DEBUG_NEW_OP_PRINTF();
+
+    return _heap_abi_malloc(size, false, __builtin_return_address(0));
+}
+#endif // #elif !defined(__cpp_exceptions)  #if defined(UMM_ENABLE_MEMALIGN)
+#else
+/*
+  Using weaklink C++ Exception handlers in libstdc. The "new" operators that
+  express alignment should work through libstdc via memalign() in the umm_malloc
+  library.
+
+  Note that libstdc will fail errors in alignment value early. Thus, the
+  UMM_STATS_FULL alignment error count will be zero.
+
+  This saves about 20 bytes in the UMM_ENABLE_MEMALIGN=1 case and 32 bytes when
+  UMM_ENABLE_MEMALIGN=0.
+
+*/
+//D <<
+//C temporary pragmas remove before merge
+#pragma message("Using weaklink C++ Exception handlers in libstdc")
+#if UMM_ENABLE_MEMALIGN
+#pragma message("The \"new\" operators that express alignment should work through libstdc via memalign() in the umm_malloc library.")
+//D >>
+#endif
+
+#endif // #if defined(__cpp_exceptions)
+
 
 void __cxa_pure_virtual(void)
 {