Lite refactoring and expanded comments

lite refactoring of DEBUG_ESP_OOM printing
Overall refactoring to make easier to follow.
Added ABI changes includes atomic save of OOM debug info
Added debug support for C++ "delete" operator

Avoid identifying the wrapper code as the source of the Heap call.
Each outer wrapper passes the caller's address down to the next level.

Improves "caller" address reporting for OOM and Poison events.
Previously, some OOM and Poison events reported info pointing to the thick heap
wrapper rather than back to the caller. Update abi.cpp, heap.cpp and umm_local.c
(umm_poison) to support caller parameter.

Author: mhightower83

cores/esp8266/abi.cpp

@@ -24,57 +24,33 @@
 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 unhandle, 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)
 
 // 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