Implementing object model, memory allocators finalization routines. Adding assertion that all memory was freed before exit.

src/liballocator/mem-allocator.c

@@ -38,15 +38,32 @@ JERRY_STATIC_ASSERT( MEM_HEAP_AREA_SIZE <= 64 * 1024 );
 void
 mem_init( void)
 {
-    mem_heap_init( mem_heap_area, sizeof (mem_heap_area));
-    mem_pools_init();
+  mem_heap_init( mem_heap_area, sizeof (mem_heap_area));
+  mem_pools_init();
 } /* mem_init */
 
+/**
+ * Finalize memory allocators.
+ */
+void
+mem_finalize( bool is_show_mem_stats) /**< show heap memory stats
+                                           before finalization? */
+{
+  mem_pools_finalize();
+
+  if (is_show_mem_stats)
+    {
+      mem_heap_print( false, false, true);
+    }
+
+  mem_heap_finalize();
+} /* mem_finalize */
+
 /**
  * Get base pointer for allocation area.
  */
 uintptr_t
 mem_get_base_pointer( void)
 {
-    return (uintptr_t) mem_heap_area;
+  return (uintptr_t) mem_heap_area;
 } /* mem_get_base_pointer */

src/liballocator/mem-allocator.h

@@ -37,6 +37,7 @@
 #define MEM_ALIGNMENT       (1 << MEM_ALIGNMENT_LOG)
 
 extern void mem_init(void);
+extern void mem_finalize(bool is_show_mem_stats);
 uintptr_t mem_get_base_pointer(void);
 
 #endif /* !JERRY_MEM_ALLOCATOR_H */

src/liballocator/mem-heap.c

@@ -40,14 +40,14 @@
 # define VALGRIND_DEFINED_STRUCT( s)     (void)VALGRIND_MAKE_MEM_DEFINED( ( s ), sizeof( *( s ) ) )
 # define VALGRIND_NOACCESS_SPACE( p, s)  (void)VALGRIND_MAKE_MEM_NOACCESS( ( p ), ( s ) )
 # define VALGRIND_UNDEFINED_SPACE( p, s) (void)VALGRIND_MAKE_MEM_UNDEFINED( ( p ), ( s ) )
-# define VALGRIND_DEFINED_SPACET( p, s)  (void)VALGRIND_MAKE_MEM_DEFINED( ( p ), ( s ) )
+# define VALGRIND_DEFINED_SPACE( p, s)   (void)VALGRIND_MAKE_MEM_DEFINED( ( p ), ( s ) )
 #else /* !JERRRY_NVALGRIND */
 # define VALGRIND_NOACCESS_STRUCT( s)
 # define VALGRIND_UNDEFINED_STRUCT( s)
 # define VALGRIND_DEFINED_STRUCT( s)
 # define VALGRIND_NOACCESS_SPACE( p, s)
 # define VALGRIND_UNDEFINED_SPACE( p, s)
-# define VALGRIND_DEFINED_SPACET( p, s)
+# define VALGRIND_DEFINED_SPACE( p, s)
 #endif /* !JERRY_NVALGRIND */
 
 /**
@@ -225,6 +225,22 @@ mem_heap_init(uint8_t *heap_start, /**< first address of heap space */
   mem_heap_stat_init();
 } /* mem_heap_init */
 
+/**
+ * Finalize heap
+ */
+void
+mem_heap_finalize(void)
+{
+  VALGRIND_DEFINED_SPACE( mem_heap.heap_start, mem_heap.heap_size);
+
+  JERRY_ASSERT( mem_heap.first_block_p == mem_heap.last_block_p );
+  JERRY_ASSERT( mem_heap.first_block_p->magic_num == MEM_MAGIC_NUM_OF_FREE_BLOCK );
+
+  VALGRIND_NOACCESS_SPACE( mem_heap.heap_start, mem_heap.heap_size);
+
+  __memset( &mem_heap, 0, sizeof(mem_heap));
+} /* mem_heap_finalize */
+
 /**
  * Initialize block header
  */

src/liballocator/mem-heap.h

@@ -39,6 +39,7 @@ typedef enum {
 } mem_heap_alloc_term_t;
 
 extern void mem_heap_init(uint8_t *heap_start, size_t heap_size);
+extern void mem_heap_finalize(void);
 extern uint8_t* mem_heap_alloc_block(size_t size_in_bytes, mem_heap_alloc_term_t alloc_term);
 extern void mem_heap_free_block(uint8_t *ptr);
 extern size_t mem_heap_recommend_allocation_size(size_t minimum_allocation_size);

src/liballocator/mem-poolman.c

@@ -122,6 +122,26 @@ mem_pools_init(void)
   mem_pools_stat_init();
 } /* mem_pools_init */
 
+/**
+ * Finalize pool manager
+ */
+void
+mem_pools_finalize(void)
+{
+  for ( uint32_t i = 0; i < MEM_POOL_CHUNK_TYPE__COUNT; i++ )
+    {
+      JERRY_ASSERT( mem_pools[ i ] == NULL );
+      JERRY_ASSERT( mem_free_chunks_number[ i ] == 0 );
+    }
+
+  JERRY_ASSERT( mem_pool_for_pool_headers.chunks_number == mem_pool_for_pool_headers.free_chunks_number );
+
+  __memset( &mem_pool_for_pool_headers, 0, sizeof(mem_pool_for_pool_headers));
+
+  mem_heap_free_block( mem_space_for_pool_for_pool_headers);
+  mem_space_for_pool_for_pool_headers = NULL;
+} /* mem_pools_finalize */
+
 /**
  * Allocate a chunk of specified size
  * 

src/liballocator/mem-poolman.h

@@ -54,6 +54,7 @@ typedef enum {
 extern size_t mem_get_chunk_size( mem_pool_chunk_type_t chunk_type);
 
 extern void mem_pools_init(void);
+extern void mem_pools_finalize(void);
 extern uint8_t* mem_pools_alloc(mem_pool_chunk_type_t chunk_type);
 extern void mem_pools_free(mem_pool_chunk_type_t chunk_type, uint8_t *chunk_p);