Updated changes to match upstream style using uncrustify.

Removed '//D' block comments

Removed redundant title sub-string from DEV_DEBUG_ABI_CPP.

Moved some operation delete's with respect to build macros
such that they were built when needed.

Author: mhightower83

cores/esp8266/abi.cpp

@@ -36,8 +36,8 @@ extern "C" void __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
 
 
 #if DEV_DEBUG_ABI_CPP
-extern "C" void _dbg_abi_print_pstr(const char* op, const char *function_name);
-#define DEBUG_NEW_OP_PRINTF() _dbg_abi_print_pstr("new_op", __PRETTY_FUNCTION__)
+extern "C" void _dbg_abi_print_pstr(const char *function_name);
+#define DEBUG_NEW_OP_PRINTF() _dbg_abi_print_pstr(__PRETTY_FUNCTION__)
 #else
 #define DEBUG_NEW_OP_PRINTF() do { } while (false)
 #endif
@@ -148,6 +148,8 @@ void* operator new[] (std::size_t size, std::align_val_t alignment, const std::n
     }
 }
 
+// default alignment
+
 // new_op
 void* operator new (std::size_t size)
 {
@@ -288,6 +290,8 @@ void* operator new[] (size_t size, std::align_val_t alignment, const std::nothro
     return _heap_abi_memalign(std::size_t(alignment), size, false, __builtin_return_address(0));
 }
 
+// default alignment
+
 void* operator new (size_t size)
 {
     DEBUG_NEW_OP_PRINTF();
@@ -361,16 +365,7 @@ void* operator new[] (size_t size, const std::nothrow_t&)
 
   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.")
-#endif
-//D >>
-
 #endif // #if defined(__cpp_exceptions)
 
 

cores/esp8266/heap.cpp

@@ -805,10 +805,10 @@ bool abi_new_print = false;
 #define DEBUG_ABI_CPP_PRINTF ets_uart_printf
 
 // _dbg_abi_print_pstr is shared (private) between abi.cpp and heap.cpp
-extern "C" void _dbg_abi_print_pstr(const char* op, const char *function_name) {
+extern "C" void _dbg_abi_print_pstr(const char *function_name) {
     if (abi_new_print) {
         uint32_t saved_ps = xt_rsil(DEFAULT_CRITICAL_SECTION_INTLEVEL);
-        DEBUG_HEAP_PRINTF("\nTrace %s: ", op);
+        DEBUG_HEAP_PRINTF("\nTrace: ");
         if (withinISR(saved_ps)) {
             DEBUG_HEAP_PRINTF("FN(%p)", function_name);
         } else {
@@ -821,7 +821,7 @@ extern "C" void _dbg_abi_print_pstr(const char* op, const char *function_name) {
     }
 }
 // #define DEBUG_DELETE_OP_PRINT_FN() do { _dbg_abi_print_pstr("delete_op", __PRETTY_FUNCTION__, __builtin_return_address(0)); } while (false)
-#define DEBUG_DELETE_OP_PRINT_FN() do { _dbg_abi_print_pstr("delete_op", __PRETTY_FUNCTION__); } while (false)
+#define DEBUG_DELETE_OP_PRINT_FN() do { _dbg_abi_print_pstr(__PRETTY_FUNCTION__); } while (false)
 
 #else
 #define DEBUG_DELETE_OP_PRINT_FN(...) do { } while (false)
@@ -972,57 +972,58 @@ void operator delete[] (void *ptr, const std::nothrow_t&) noexcept
 }
 
 // del_opvs
-void operator delete[] (void *ptr,[[maybe_unused]]std::size_t size) noexcept
+void operator delete[] (void *ptr, [[maybe_unused]]std::size_t size) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
     DEBUG_ABI_CPP_PRINTF(", ptr(%p), size(%u), caller(%p)\n", ptr, size, __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
 
-#if defined(__cpp_exceptions)
 #if defined(UMM_ENABLE_MEMALIGN)
-// del_opa
-void operator delete (void* ptr, [[maybe_unused]]std::align_val_t alignment) noexcept
+
+// del_opant
+void operator delete (void *ptr, [[maybe_unused]]std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
-    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
+    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), std::nothrow_t, caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
 
-// del_opant
-void operator delete (void *ptr, [[maybe_unused]]std::align_val_t alignment, const std::nothrow_t&) noexcept
+// del_opvant
+void operator delete[] (void *ptr, [[maybe_unused]]std::align_val_t alignment, const std::nothrow_t&) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
     DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), std::nothrow_t, caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
+///////////////////////////////////////////////////////////////////////////////
 
-// del_opsa
-void operator delete (void* ptr, [[maybe_unused]]std::size_t size, [[maybe_unused]]std::align_val_t alignment) noexcept
+// del_opa
+void operator delete (void* ptr, [[maybe_unused]]std::align_val_t alignment) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
-    DEBUG_ABI_CPP_PRINTF(", ptr(%p), size(%u), alignment(%u), caller(%p)\n", ptr, size, std::size_t(alignment), __builtin_return_address(0));
+    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
 
-// del_opva
-void operator delete[] (void *ptr, [[maybe_unused]]std::align_val_t alignment) noexcept
+// del_opsa
+void operator delete (void* ptr, [[maybe_unused]]std::size_t size, [[maybe_unused]]std::align_val_t alignment) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
-    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
+    DEBUG_ABI_CPP_PRINTF(", ptr(%p), size(%u), alignment(%u), caller(%p)\n", ptr, size, std::size_t(alignment), __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
 
-// del_opvant
-void operator delete[] (void *ptr, [[maybe_unused]]std::align_val_t alignment, const std::nothrow_t&) noexcept
+// del_opva
+void operator delete[] (void *ptr, [[maybe_unused]]std::align_val_t alignment) noexcept
 {
     DEBUG_DELETE_OP_PRINT_FN();
-    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), std::nothrow_t, caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
+    DEBUG_ABI_CPP_PRINTF(", ptr(%p), alignment(%u), caller(%p)\n", ptr, std::size_t(alignment), __builtin_return_address(0));
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
@@ -1035,7 +1036,6 @@ void operator delete[] (void *ptr, [[maybe_unused]]std::size_t size, [[maybe_unu
 
     _heap_delete(ptr, __builtin_return_address(0));
 }
-#endif  // #if defined(UMM_ENABLE_MEMALIGN)
-#endif // #if defined(__cpp_exceptions)
 
-#endif
+#endif  // #if defined(UMM_ENABLE_MEMALIGN)
+#endif  // #if defined(ENABLE_THICK_DEBUG_WRAPPERS)

cores/esp8266/umm_malloc/umm_local.h

@@ -35,8 +35,8 @@ static size_t umm_uadd_sat(const size_t a, const size_t b);
 
 
 #if defined(DEBUG_ESP_OOM) || defined(UMM_POISON_CHECK) \
-|| defined(UMM_POISON_CHECK_LITE) || defined(UMM_INTEGRITY_CHECK) \
-|| defined(DEBUG_ESP_WITHINISR)
+    || defined(UMM_POISON_CHECK_LITE) || defined(UMM_INTEGRITY_CHECK) \
+    || defined(DEBUG_ESP_WITHINISR)
 #else
 #define umm_malloc(s)           malloc(s)
 #define umm_memalign(a,s)       memalign(a,s)

cores/esp8266/umm_malloc/umm_malloc.cpp

@@ -536,14 +536,14 @@ void ICACHE_MAYBE umm_init_heap(size_t id, void *start_addr, size_t size, bool f
     // Our default target alignment is __STDCPP_DEFAULT_NEW_ALIGNMENT__ == 8
     // To return malloc memory 8-byte aligned, we have to sacrifice 4-bytes at
     // beginning and end of the heap address space.
-#if defined(UMM_LEGACY_ALIGN_4BYTE) && defined(UMM_ENABLE_MEMALIGN)
+    #if defined(UMM_LEGACY_ALIGN_4BYTE) && defined(UMM_ENABLE_MEMALIGN)
     #error "Build option conflict - cannot support both UMM_LEGACY_ALIGN_4BYTE and UMM_ENABLE_MEMALIGN"
-#elif defined(UMM_LEGACY_ALIGN_4BYTE)
+    #elif defined(UMM_LEGACY_ALIGN_4BYTE)
     _context->heap = (umm_block *)((uintptr_t)start_addr);
-#else
+    #else
     _context->heap = (umm_block *)((uintptr_t)start_addr + 4u);
     size -= 4u;
-#endif
+    #endif
     _context->numblocks = (size / sizeof(umm_block));
     _context->heap_end = (void *)((uintptr_t)_context->heap + _context->numblocks * sizeof(umm_block));
 
@@ -725,12 +725,12 @@ static void *umm_malloc_core(umm_heap_context_t *_context, size_t size)
 
     STATS__ALLOC_REQUEST(id_malloc, size);
 
-#if UMM_ENABLE_MEMALIGN
+    #if UMM_ENABLE_MEMALIGN
     if (alignment) {
         // Pad size to cover alignment adjustments
         size += alignment;
     }
-#endif
+    #endif
 
     blocks = umm_blocks(size);
 
@@ -780,7 +780,7 @@ static void *umm_malloc_core(umm_heap_context_t *_context, size_t size)
 
         UMM_FRAGMENTATION_METRIC_REMOVE(cf);
 
-#if UMM_ENABLE_MEMALIGN
+        #if UMM_ENABLE_MEMALIGN
         if (__builtin_expect(alignment, 0u)) {
             size_t alignMask = (alignment - 1u);
             uintptr_t aptr = (uintptr_t)&UMM_DATA(cf);
@@ -816,7 +816,7 @@ static void *umm_malloc_core(umm_heap_context_t *_context, size_t size)
                 blocks -= frag;
             }
         }
-#endif
+        #endif
 
         /*
          * This is an existing block in the memory heap, we just need to split off
@@ -957,15 +957,15 @@ void *umm_malloc(size_t size)
         return ptr;
     }
 
-#if UMM_ENABLE_MEMALIGN
+    #if UMM_ENABLE_MEMALIGN
 
     /*
      * Ensure alignment is power of 2; however, we allow zero.
      */
 
     if (0u != (alignment & (alignment - 1u))) {
-      STATS__ALIGNMENT_ERROR(id_malloc, alignment);
-      return ptr;
+        STATS__ALIGNMENT_ERROR(id_malloc, alignment);
+        return ptr;
     }
 
     /*
@@ -979,7 +979,7 @@ void *umm_malloc(size_t size)
     if (alignment <= sizeof(umm_block)) {
         alignment = 0u;   // Use implementation default/minimum, 8.
     }
-#endif
+    #endif
 
     /* Allocate the memory within a protected critical section */
 

cores/esp8266/umm_malloc/umm_malloc_cfgport.h

@@ -134,18 +134,6 @@ extern char _heap_start[];
 #undef UMM_ENABLE_MEMALIGN
 #endif
 
-//D
-//D #ifndef __STRINGIFY
-//D #define __STRINGIFY(a) #a
-//D #endif
-//D #define QUOTE(a) __STRINGIFY(a)
-//D #pragma message("UMM_ENABLE_MEMALIGN: \"" QUOTE(UMM_ENABLE_MEMALIGN) "\"")
-//D #ifdef UMM_ENABLE_MEMALIGN
-//D #pragma message("UMM_ENABLE_MEMALIGN defined")
-//D #else
-//D #pragma message("UMM_ENABLE_MEMALIGN not defined")
-//D #endif
-
 /*
  * The NONOS SDK API requires function `umm_info()` for implementing
  * `system_show_malloc()`. Build option `-DUMM_INFO` enables this support.