adwadwa

[vg.git] / vg_mem.h

diff --git a/vg_mem.h b/vg_mem.h
index 9a9b31bed02baa84f2e36bcff4bb7546af5fd002..fbebaf8342f468c6d27ca888fa388ad71da9937c 100644 (file)
--- a/vg_mem.h
+++ b/vg_mem.h
@@ -8,6 +8,8 @@
 #include <stdlib.h>
 #include <malloc.h>
 
+void vg_print_backtrace(void);
+
 #define VG_MAX_ALLOCATIONS 128
 #define VG_FUZZ_ALLOCATIONS
 
@@ -115,16 +117,19 @@ static vg_linear_allocator *vg_linear_header( void *data )
 __attribute__((warn_unused_result))
 VG_STATIC void *vg_linear_alloc( void *buffer, u32 size )
 {
-   if( size % 8 )
-   {
+   if( size % 8 ){
       vg_error( "alloc(%u) is not 8 byte aligned\n", size );
+      vg_print_backtrace();
       size = vg_align8( size );
    }
+   if( ((u64)buffer) % 8 ){
+      vg_error( "buffer: %p\n", buffer );
+      vg_fatal_exit_loop( "unaligned buffer" );
+   }
 
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
-   if( (alloc->cur + size) > alloc->size )
-   {
+   if( (alloc->cur + size) > alloc->size ){
       vg_error( "%u + %u > %u\n", alloc->cur, size, alloc->size );
       vg_fatal_exit_loop( "linear allocator overflow" );
    }
@@ -135,34 +140,46 @@ VG_STATIC void *vg_linear_alloc( void *buffer, u32 size )
 
    void *data;
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       data = malloc( size );
 
       vg_allocation_meta *meta = &alloc->alloc_table[ alloc->allocation_count ];
       meta->type = k_allocation_type_block;
       meta->data = data;
    }
-   else
-   {
+   else{
       data = buffer + alloc->cur;
    }
 
+   u8 *bytes = data;
+   for( u32 i=0; i<size; i++ ){
+      bytes[i] = 0xae;
+   }
+
    alloc->allocation_count ++;
    alloc->last_alloc = data;
    alloc->last_alloc_size = size;
    alloc->cur += size;
 
+   if( ((u64)data) % 8 ){
+      vg_fatal_exit_loop( "unaligned" );
+   }
+
    return data;
 }
 
-
 /* resize latest block of memory from linear */
 __attribute__((warn_unused_result))
 VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
 {
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
+   if( newsize % 8 ){
+      vg_error( "alloc(%u) is not 8 byte aligned\n", newsize );
+      vg_print_backtrace();
+      newsize = vg_align8( newsize );
+   }
+
    if( alloc->last_alloc != data )
       vg_fatal_exit_loop( "This block has been fixed!" );
 
@@ -173,8 +190,7 @@ VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
    alloc->cur += newsize;
    alloc->last_alloc_size = newsize;
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       data = realloc( data, newsize );
       if( !data )
          vg_fatal_exit_loop( "realloc failed" );
@@ -183,8 +199,7 @@ VG_STATIC void *vg_linear_resize( void *buffer, void *data, u32 newsize )
       alloc->last_alloc = data;
       return data;
    }
-   else
-   {
+   else{
       return data;
    }
 }
@@ -197,8 +212,7 @@ VG_STATIC void vg_linear_del( void *buffer, void *data )
    if( alloc->last_alloc != data )
       vg_fatal_exit_loop( "This block has been fixed!" );
 
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
       vg_allocation_meta *meta = &alloc->alloc_table[alloc->allocation_count-1];
       if( meta->type == k_allocation_type_linear )
          vg_fatal_exit_loop( "Cannot free a linear allocator in this conext" );
@@ -255,18 +269,14 @@ VG_STATIC void vg_linear_clear( void *buffer )
    vg_linear_allocator *alloc = vg_linear_header( buffer );
 
    /* libc mode we recursively free any allocations made */
-   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) )
-   {
-      for( u32 i=0; i<alloc->allocation_count; i++ )
-      {
+   if( vg_mem.use_libc_malloc && (alloc->flags & VG_MEMORY_SYSTEM) ){
+      for( u32 i=0; i<alloc->allocation_count; i++ ){
          vg_allocation_meta *meta = &alloc->alloc_table[i];
          
-         if( meta->type == k_allocation_type_block )
-         {
+         if( meta->type == k_allocation_type_block ){
             free( meta->data );
          }
-         else
-         {
+         else{
             vg_linear_clear( meta->data );
             vg_linear_allocator *sub = vg_linear_header( meta->data );
 
@@ -292,8 +302,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
    u32 block_size = size + sizeof(vg_linear_allocator);
    
    /* Creating it inside an existing one */
-   if( lin_alloc )
-   {
+   if( lin_alloc ){
       vg_linear_allocator *alloc = vg_linear_header( lin_alloc );
 
       if( alloc->cur + block_size > alloc->size )
@@ -306,8 +315,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
          vg_fatal_exit_loop( "Cannot declare realtime allocator inside systems"
                              " allocator" );
 
-      if( vg_mem.use_libc_malloc )
-      {
+      if( vg_mem.use_libc_malloc ){
          vg_allocation_meta *meta = 
             &alloc->alloc_table[ alloc->allocation_count ];
          
@@ -319,8 +327,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
          meta->data = header+1;
          meta->type = k_allocation_type_linear;
       }
-      else
-      {
+      else{
          header = lin_alloc + alloc->cur;
       }
       
@@ -345,8 +352,7 @@ VG_STATIC void *vg_create_linear_allocator( void *lin_alloc, u32 size,
    header->size = size;
    header->flags = flags;
 
-   if( vg_mem.use_libc_malloc && (flags & VG_MEMORY_SYSTEM) )
-   {
+   if( vg_mem.use_libc_malloc && (flags & VG_MEMORY_SYSTEM) ){
       u32 table_size = sizeof(vg_allocation_meta)*VG_MAX_ALLOCATIONS;
       header->alloc_table = malloc( table_size );
    }