Heap: Improve debug caller address reporting

cores/esp8266/abi.cpp

@@ -24,57 +24,67 @@
 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);
 
 extern "C" void __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
 extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
 
+#if defined(__cpp_exceptions) && (defined(DEBUG_ESP_OOM) || defined(DEBUG_ESP_PORT) || defined(DEBUG_ESP_WITHINISR))
+/*
+  When built with C++ Exceptions: "enabled", track caller address of Last OOM.
+  * For debug build, force enable Last OOM tracking.
+  * With the option "DEBUG_ESP_OOM," always do Last OOM tracking.
+  * Otherwise, disable Last OOM tracking. The build relies on the weak link to
+    the default C++ exception handler.
+*/
+
+// Debug replacement adaptation from ".../new_op.cc".
+using std::new_handler;
+using std::bad_alloc;
+
+void * operator new (std::size_t size)
+{
+    void *p;
+
+    /* malloc (0) is unpredictable; avoid it.  */
+    if (__builtin_expect(size == 0, false)) {
+        size = 1;
+    }
 
-#if !defined(__cpp_exceptions)
+    while (0 == (p = _heap_abi_malloc(size, false, __builtin_return_address(0)))) {
+        new_handler handler = std::get_new_handler();
+        if (!handler) {
+            throw(bad_alloc());
+        }
+        handler();
+    }
+
+    return p;
+}
+#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
 
 void* operator new(size_t size)
 {
-    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"));
-    }
-    return ret;
+    return _heap_abi_malloc(size, true, __builtin_return_address(0));
 }
 
 void* operator new[](size_t size)
 {
-    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"));
-    }
-    return ret;
+    return _heap_abi_malloc(size, true, __builtin_return_address(0));
 }
 
 void* operator new (size_t size, const std::nothrow_t&)
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
-    }
-    return ret;
+    return _heap_abi_malloc(size, false, __builtin_return_address(0));
 }
 
 void* operator new[] (size_t size, const std::nothrow_t&)
 {
-    void *ret = malloc(size);
-    if (0 != size && 0 == ret) {
-        umm_last_fail_alloc_addr = __builtin_return_address(0);
-        umm_last_fail_alloc_size = size;
-    }
-    return ret;
+    return _heap_abi_malloc(size, false, __builtin_return_address(0));
 }
 
 #endif // !defined(__cpp_exceptions)

cores/esp8266/core_esp8266_postmortem.cpp

@@ -36,41 +36,47 @@
 
 extern "C" {
 
-// These will be pointers to PROGMEM const strings
-static const char* s_panic_file = 0;
-static int s_panic_line = 0;
-static const char* s_panic_func = 0;
-static const char* s_panic_what = 0;
-
-// Our wiring for abort() and C++ exceptions
-static bool s_abort_called = false;
-static const char* s_unhandled_exception = NULL;
-
-// Common way to notify about where the stack smashing happened
-// (but, **only** if caller uses our handler function)
-static uint32_t s_stacksmash_addr = 0;
-
-void abort() __attribute__((noreturn));
-static void uart_write_char_d(char c);
-static void uart0_write_char_d(char c);
-static void uart1_write_char_d(char c);
-static void print_stack(uint32_t start, uint32_t end);
-
 // using numbers different from "REASON_" in user_interface.h (=0..6)
 enum rst_reason_sw
 {
     REASON_USER_STACK_SMASH = 253,
     REASON_USER_SWEXCEPTION_RST = 254
 };
-static int s_user_reset_reason = REASON_DEFAULT_RST;
+
+static struct PostmortemInfo {
+    int user_reset_reason;    // REASON_DEFAULT_RST;
+
+    // These will be pointers to PROGMEM const strings
+    const char* panic_file;   // 0;
+    int panic_line;           // 0;
+    const char* panic_func;   // 0;
+    const char* panic_what;   // 0;
+
+    // Our wiring for abort() and C++ exceptions
+    bool abort_called;        // false;
+    const char* unhandled_exception; // NULL;
+
+    // Common way to notify about where the stack smashing happened
+    // (but, **only** if caller uses our handler function)
+    uint32_t stacksmash_addr; // 0;
+} s_pm = {REASON_DEFAULT_RST, 0, 0, 0, 0, false, NULL, 0};
 
 // From UMM, the last caller of a malloc/realloc/calloc which failed:
-extern void *umm_last_fail_alloc_addr;
-extern int umm_last_fail_alloc_size;
+extern struct umm_last_fail_alloc {
+    const void *addr;
+    size_t size;
 #if defined(DEBUG_ESP_OOM)
-extern const char *umm_last_fail_alloc_file;
-extern int umm_last_fail_alloc_line;
+    const char *file;
+    int line;
 #endif
+} _umm_last_fail_alloc;
+
+
+void abort() __attribute__((noreturn));
+static void uart_write_char_d(char c);
+static void uart0_write_char_d(char c);
+static void uart1_write_char_d(char c);
+static void print_stack(uint32_t start, uint32_t end);
 
 static void raise_exception() __attribute__((noreturn));
 
@@ -116,7 +122,7 @@ void __wrap_system_restart_local() {
 
     struct rst_info rst_info;
     memset(&rst_info, 0, sizeof(rst_info));
-    if (s_user_reset_reason == REASON_DEFAULT_RST)
+    if (s_pm.user_reset_reason == REASON_DEFAULT_RST)
     {
         system_rtc_mem_read(0, &rst_info, sizeof(rst_info));
         if (rst_info.reason != REASON_SOFT_WDT_RST &&
@@ -127,23 +133,23 @@ void __wrap_system_restart_local() {
         }
     }
     else
-        rst_info.reason = s_user_reset_reason;
+        rst_info.reason = s_pm.user_reset_reason;
 
     ets_install_putc1(&uart_write_char_d);
 
     cut_here();
 
-    if (s_panic_line) {
-        ets_printf_P(PSTR("\nPanic %S:%d %S"), s_panic_file, s_panic_line, s_panic_func);
-        if (s_panic_what) {
-            ets_printf_P(PSTR(": Assertion '%S' failed."), s_panic_what);
+    if (s_pm.panic_line) {
+        ets_printf_P(PSTR("\nPanic %S:%d %S"), s_pm.panic_file, s_pm.panic_line, s_pm.panic_func);
+        if (s_pm.panic_what) {
+            ets_printf_P(PSTR(": Assertion '%S' failed."), s_pm.panic_what);
         }
         ets_putc('\n');
     }
-    else if (s_unhandled_exception) {
-        ets_printf_P(PSTR("\nUnhandled C++ exception: %S\n"), s_unhandled_exception);
+    else if (s_pm.unhandled_exception) {
+        ets_printf_P(PSTR("\nUnhandled C++ exception: %S\n"), s_pm.unhandled_exception);
     }
-    else if (s_abort_called) {
+    else if (s_pm.abort_called) {
         ets_printf_P(PSTR("\nAbort called\n"));
     }
     else if (rst_info.reason == REASON_EXCEPTION_RST) {
@@ -159,8 +165,8 @@ void __wrap_system_restart_local() {
     else if (rst_info.reason == REASON_USER_STACK_SMASH) {
         ets_printf_P(PSTR("\nStack smashing detected.\n"));
         ets_printf_P(PSTR("\nException (%d):\nepc1=0x%08x epc2=0x%08x epc3=0x%08x excvaddr=0x%08x depc=0x%08x\n"),
-            5 /* Alloca exception, closest thing to stack fault*/, s_stacksmash_addr, 0, 0, 0, 0);
-   }
+            5 /* Alloca exception, closest thing to stack fault*/, s_pm.stacksmash_addr, 0, 0, 0, 0);
+    }
     else {
         ets_printf_P(PSTR("\nGeneric Reset\n"));
     }
@@ -211,22 +217,22 @@ void __wrap_system_restart_local() {
     ets_printf_P(PSTR("<<<stack<<<\n"));
 
     // Use cap-X formatting to ensure the standard EspExceptionDecoder doesn't match the address
-    if (umm_last_fail_alloc_addr) {
+    if (_umm_last_fail_alloc.addr) {
 #if defined(DEBUG_ESP_OOM)
         ets_printf_P(PSTR("\nlast failed alloc call: %08X(%d)@%S:%d\n"),
-            (uint32_t)umm_last_fail_alloc_addr, umm_last_fail_alloc_size,
-            umm_last_fail_alloc_file, umm_last_fail_alloc_line);
+            (uint32_t)_umm_last_fail_alloc.addr, _umm_last_fail_alloc.size,
+            _umm_last_fail_alloc.file, _umm_last_fail_alloc.line);
 #else
-        ets_printf_P(PSTR("\nlast failed alloc call: %08X(%d)\n"), (uint32_t)umm_last_fail_alloc_addr, umm_last_fail_alloc_size);
+        ets_printf_P(PSTR("\nlast failed alloc call: %08X(%d)\n"), (uint32_t)_umm_last_fail_alloc.addr, _umm_last_fail_alloc.size);
 #endif
     }
 
     cut_here();
 
-    if (s_unhandled_exception && umm_last_fail_alloc_addr) {
+    if (s_pm.unhandled_exception && _umm_last_fail_alloc.addr) {
         // now outside from the "cut-here" zone, print correctly the `new` caller address,
         // idf-monitor.py will be able to decode this one and show exact location in sources
-        ets_printf_P(PSTR("\nlast failed alloc caller: 0x%08x\n"), (uint32_t)umm_last_fail_alloc_addr);
+        ets_printf_P(PSTR("\nlast failed alloc caller: 0x%08x\n"), (uint32_t)_umm_last_fail_alloc.addr);
     }
 
     custom_crash_callback( &rst_info, sp_dump + offset, stack_end );
@@ -275,45 +281,45 @@ static void raise_exception() {
     if (gdb_present())
         __asm__ __volatile__ ("syscall"); // triggers GDB when enabled
 
-    s_user_reset_reason = REASON_USER_SWEXCEPTION_RST;
+    s_pm.user_reset_reason = REASON_USER_SWEXCEPTION_RST;
     ets_printf_P(PSTR("\nUser exception (panic/abort/assert)"));
     __wrap_system_restart_local();
 
     while (1); // never reached, needed to satisfy "noreturn" attribute
 }
 
 void abort() {
-    s_abort_called = true;
+    s_pm.abort_called = true;
     raise_exception();
 }
 
 void __unhandled_exception(const char *str) {
-    s_unhandled_exception = str;
+    s_pm.unhandled_exception = str;
     raise_exception();
 }
 
 void __assert_func(const char *file, int line, const char *func, const char *what) {
-    s_panic_file = file;
-    s_panic_line = line;
-    s_panic_func = func;
-    s_panic_what = what;
+    s_pm.panic_file = file;
+    s_pm.panic_line = line;
+    s_pm.panic_func = func;
+    s_pm.panic_what = what;
     gdb_do_break();     /* if GDB is not present, this is a no-op */
     raise_exception();
 }
 
 void __panic_func(const char* file, int line, const char* func) {
-    s_panic_file = file;
-    s_panic_line = line;
-    s_panic_func = func;
-    s_panic_what = 0;
+    s_pm.panic_file = file;
+    s_pm.panic_line = line;
+    s_pm.panic_func = func;
+    s_pm.panic_what = 0;
     gdb_do_break();     /* if GDB is not present, this is a no-op */
     raise_exception();
 }
 
 uintptr_t __stack_chk_guard = 0x08675309 ^ RANDOM_REG32;
 void __stack_chk_fail(void) {
-    s_user_reset_reason = REASON_USER_STACK_SMASH;
-    s_stacksmash_addr = (uint32_t)__builtin_return_address(0);
+    s_pm.user_reset_reason = REASON_USER_STACK_SMASH;
+    s_pm.stacksmash_addr = (uint32_t)__builtin_return_address(0);
 
     if (gdb_present())
         __asm__ __volatile__ ("syscall"); // triggers GDB when enabled