ecere/com: (#1044) Added option to disable memory manager

- Also fixed a potential leak on invoking renew0 with a 0 size on an existing buffer
- Added a CheckConsistency() call to check MemoryGuard blocks integrity, added info to buffer over/underruns

diff --git a/compiler/bootstrap/ecere/bootstrap/instance.c b/compiler/bootstrap/ecere/bootstrap/instance.c
index 8156c2c..92aa279 100644 (file)
--- a/compiler/bootstrap/ecere/bootstrap/instance.c
+++ b/compiler/bootstrap/ecere/bootstrap/instance.c
@@ -216,6 +216,10 @@ return power;
 
 static unsigned int __ecereNameSpace__ecere__com__memoryInitialized = 0;
 
+void __ecereNameSpace__ecere__com__CheckConsistency()
+{
+}
+
 void __ecereNameSpace__ecere__com__CheckMemory()
 {
 }
@@ -1551,7 +1555,10 @@ return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
 static void * __ecereNameSpace__ecere__com___crealloc(void * pointer, unsigned int size)
 {
 if(!size)
+{
+__ecereNameSpace__ecere__com___free(pointer);
 return (((void *)0));
+}
 pointer = __ecereNameSpace__ecere__com___mycrealloc(pointer, size);
 return pointer ? ((unsigned char *)pointer + 0) : (((void *)0));
 }
@@ -6649,6 +6656,7 @@ __ecereNameSpace__ecere__com__eClass_AddDataMember(class, "usedSpace", "uint", 4
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::log2i", "uint ecere::com::log2i(uint number)", __ecereNameSpace__ecere__com__log2i, module, 4);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::pow2i", "uint ecere::com::pow2i(uint number)", __ecereNameSpace__ecere__com__pow2i, module, 4);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::memswap", "void ecere::com::memswap(byte * a, byte * b, uint size)", __ecereNameSpace__ecere__com__memswap, module, 4);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::CheckConsistency", "void ecere::com::CheckConsistency(void)", __ecereNameSpace__ecere__com__CheckConsistency, module, 4);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::CheckMemory", "void ecere::com::CheckMemory(void)", __ecereNameSpace__ecere__com__CheckMemory, module, 4);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eSystem_RegisterClass", "ecere::com::Class ecere::com::eSystem_RegisterClass(ecere::com::ClassType type, const char * name, const char * baseName, int size, int sizeClass, bool (* Constructor)(void *), void (* Destructor)(void *), ecere::com::Module module, ecere::com::AccessMode declMode, ecere::com::AccessMode inheritanceAccess)", __ecereNameSpace__ecere__com__eSystem_RegisterClass, module, 4);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::com::eClass_Unregister", "void ecere::com::eClass_Unregister(ecere::com::Class _class)", __ecereNameSpace__ecere__com__eClass_Unregister, module, 4);

diff --git a/ecere/src/com/instance.ec b/ecere/src/com/instance.ec
index c06d29b..7b95aaf 100644 (file)
--- a/ecere/src/com/instance.ec
+++ b/ecere/src/com/instance.ec
@@ -1,5 +1,7 @@
 namespace com;
 
+// #define DISABLE_MEMMGR
+
 import "BinaryTree"
 import "OldList"
 import "String"
@@ -49,6 +51,28 @@ static uint memoryErrorsCount = 0;
 default:
 #define property _property
 
+#if defined(DISABLE_MEMMGR)
+
+#ifndef ECERE_BOOTSTRAP
+# include <malloc.h>
+#endif
+
+#if defined(__WIN32__)
+#ifdef ECERE_BOOTSTRAP
+uintsize _msize(void * p);
+#endif
+
+#  define msize _msize
+#else
+#ifdef ECERE_BOOTSTRAP
+uintsize malloc_usable_size(void * p);
+#endif
+
+#  define msize malloc_usable_size
+#endif
+
+#endif
+
 #include <stdlib.h>
 #include <stdio.h>
 
@@ -674,7 +698,7 @@ bool allocateInternal;
 #endif
 
 static uint TOTAL_MEM = 0;
-#ifndef MEMINFO
+#if !defined(MEMINFO) && !defined(DISABLE_MEMMGR)
 static uint OUTSIDE_MEM = 0;
 #endif
 
@@ -1053,7 +1077,7 @@ private struct BlockPool
    }
 };
 
-#ifndef MEMINFO
+#if !defined(MEMINFO) && !defined(DISABLE_MEMMGR)
 static BlockPool * pools; //[NUM_POOLS];
 
 /*static uint PosFibonacci(uint number)
@@ -1164,7 +1188,7 @@ public uint pow2i(uint number)
    return 1<<log2i(number);
 }
 
-#ifndef MEMINFO
+#if !defined(MEMINFO) && !defined(DISABLE_MEMMGR)
 static bool memoryInitialized = false;
 static void InitMemory()
 {
@@ -1190,7 +1214,7 @@ static void InitMemory()
 }
 #endif
 
-#ifndef MEMINFO
+#if !defined(MEMINFO) && !defined(DISABLE_MEMMGR)
 static void * _mymalloc(unsigned int size)
 {
    MemBlock block = null;
@@ -1360,9 +1384,7 @@ static void * _mycrealloc(void * pointer, unsigned int size)
    }
    return newPointer;
 }
-#endif
 
-#ifndef MEMINFO
 #undef realloc
 #undef crealloc
 #undef malloc
@@ -1378,8 +1400,12 @@ static void * _mycrealloc(void * pointer, unsigned int size)
 
 static void * _malloc(unsigned int size)
 {
+#if defined(DISABLE_MEMMGR) && !defined(MEMINFO)
+   return size ? malloc(size) : null;
+#else
    void * pointer;
 
+
 #if !defined(ECERE_BOOTSTRAP)
    memMutex.Wait();
 #endif
@@ -1435,11 +1461,16 @@ static void * _malloc(unsigned int size)
    }
 #endif
    return pointer ? ((byte*)pointer + REDZONE) : null;
+#endif
 }
 
 static void * _calloc(int n, unsigned int size)
 {
+#if defined(DISABLE_MEMMGR) && !defined(MEMINFO)
+   return size ? calloc(n, size) : null;
+#else
    void * pointer;
+
 #if !defined(ECERE_BOOTSTRAP)
    memMutex.Wait();
 #endif
@@ -1494,11 +1525,18 @@ static void * _calloc(int n, unsigned int size)
    }
 #endif
    return pointer ? ((byte*)pointer + REDZONE) : null;
+#endif
 }
 
 static void * _realloc(void * pointer, unsigned int size)
 {
+#if defined(DISABLE_MEMMGR) && !defined(MEMINFO)
+   if(!size) { free(pointer); return null; }
+   return realloc(pointer, size);
+
+#else
    if(!size) { _free(pointer); return null; }
+
 #if !defined(ECERE_BOOTSTRAP)
    memMutex.Wait();
 #endif
@@ -1586,11 +1624,23 @@ static void * _realloc(void * pointer, unsigned int size)
    memMutex.Release();
 #endif
    return pointer ? ((byte *)pointer + REDZONE) : null;
+#endif
 }
 
 static void * _crealloc(void * pointer, unsigned int size)
 {
-   if(!size) return null;
+#if defined(DISABLE_MEMMGR) && !defined(MEMINFO)
+   uintsize s = pointer ? msize(pointer) : 0;
+   void * p;
+   if(!size) { free(pointer); return null; }
+
+   p = realloc(pointer, size);
+   if(size > s)
+      memset((byte *)p + s, 0, size - s);
+   return p;
+#else
+   if(!size) { _free(pointer); return null; }
+
 #if !defined(ECERE_BOOTSTRAP)
    memMutex.Wait();
 #endif
@@ -1678,12 +1728,16 @@ static void * _crealloc(void * pointer, unsigned int size)
    memMutex.Release();
 #endif
    return pointer ? ((byte *)pointer + REDZONE) : null;
+#endif
 }
 
 static void _free(void * pointer)
 {
    if(pointer)
    {
+#if defined(DISABLE_MEMMGR) && !defined(MEMINFO)
+      free(pointer);
+#else
 #if !defined(ECERE_BOOTSTRAP)
       if(memMutex != pointer) memMutex.Wait();
 #endif
@@ -1757,13 +1811,13 @@ static void _free(void * pointer)
                {
                   if(address[-c-1] != 0xAB)
                   {
-                     printf("Buffer Underrun\n");
+                     printf("Buffer Underrun (%d bytes before)\n", c+1);
                      memoryErrorsCount++;
                      block.OutputStacks(block.freed);
                   }
                   if(address[c + size] != 0xAB)
                   {
-                     printf("Buffer Overrun\n");
+                     printf("Buffer Overrun (%d bytes past block of %d)\n", c);
                      memoryErrorsCount++;
                      block.OutputStacks(block.freed);
                   }
@@ -1791,6 +1845,8 @@ static void _free(void * pointer)
 #if !defined(ECERE_BOOTSTRAP)
       if(memMutex != pointer) memMutex.Release();
 #endif
+
+#endif
    }
 }
 
@@ -1809,6 +1865,14 @@ public void memswap(byte * a, byte * b, uint size)
    }
 }
 
+public void CheckConsistency()
+{
+#ifdef MEMINFO
+   if(!memBlocks.Check())
+      printf("Memory Blocks Tree Integrity Failed\n");
+#endif
+}
+
 public void CheckMemory()
 {
 #ifdef MEMINFO
@@ -1899,13 +1963,13 @@ public void CheckMemory()
       {
          if(address[-c-1] != 0xAB)
          {
-            printf("Buffer Underrun\n");
+            printf("Buffer Underrun (%d bytes before)\n", c + 1);
             memoryErrorsCount++;
             block.OutputStacks(block.freed);
          }
          if(address[c + size] != 0xAB)
          {
-            printf("Buffer Overrun\n");
+            printf("Buffer Overrun (%d bytes past)\n", c);
             memoryErrorsCount++;
             block.OutputStacks(block.freed);
          }