Changeset d6b03b7 for libcfa/src

Timestamp:

Jul 23, 2019, 4:46:27 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8fc15cf

Parents:

b5ce31e

Message:

check for type alignment and use it for storage allocation

File:

• libcfa/src/stdlib.hfa (modified) (5 diffs)

libcfa/src/stdlib.hfa

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 24 17:35:43 2019
-// Update Count     : 352
+// Last Modified On : Tue Jul 23 14:14:59 2019
+// Update Count     : 373
 //
 
@@ -17 +17 @@
 
 #include "bits/defs.hfa"
+#include "bits/align.hfa"
 
 #include <stdlib.h>                                                                             // *alloc, strto*, ato*
+
 extern "C" {
         void * memalign( size_t align, size_t size );           // malloc.h
@@ -39 +41 @@
 
         T * malloc( void ) {
-                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                else return (T *)memalign( _Alignof(T), sizeof(T) );
         } // malloc
 
         T * calloc( size_t dim ) {
-                return (T *)(void *)calloc( dim, sizeof(T) );   // C calloc
+                if ( _Alignof(T) <= libAlign() )return (T *)(void *)calloc( dim, sizeof(T) ); // C calloc
+                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
         } // calloc
 
         T * realloc( T * ptr, size_t size ) {
+                if ( unlikely( ptr == 0 ) ) return malloc();
                 return (T *)(void *)realloc( (void *)ptr, size );
         } // realloc
@@ -66 +71 @@
 
         T * alloc( void ) {
-                return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                return malloc();
         } // alloc
 
         T * alloc( char fill ) {
-                T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
+                T * ptr;
+                if ( _Alignof(T) <= libAlign() ) ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+                else ptr = (T *)memalign( _Alignof(T), sizeof(T) );
                 return (T *)memset( ptr, (int)fill, sizeof(T) ); // initialize with fill value
         } // alloc
 
         T * alloc( size_t dim ) {
-                return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
+                else return (T *)memalign( _Alignof(T), dim * sizeof(T) );
         } // alloc
 
         T * alloc( size_t dim, char fill ) {
-                T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C calloc
-                return (T *)memset( ptr, (int)fill, dim * sizeof(T) ); // initialize with fill value
+                return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
         } // alloc
 
         T * alloc( T ptr[], size_t dim ) {
-                return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
-        } // alloc
-} // distribution
-
-
-forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
+                return realloc( ptr, dim * sizeof(T) );
+        } // alloc
+} // distribution
 
 
@@ -107 +111 @@
 
         T * align_alloc( size_t align, size_t dim, char fill ) {
-                T * ptr;
                 if ( fill == '\0' ) {
-                        ptr = (T *)cmemalign( align, dim, sizeof(T) );
+                        return (T *)cmemalign( align, dim, sizeof(T) );
                 } else {
-                        ptr = (T *)memalign( align, dim * sizeof(T) );
-                        return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
+                        return (T *)memset( (T *)memalign( align, dim * sizeof(T) ), (int)fill, dim * sizeof(T) );
                 } // if
-                return ptr;
-        } // align_alloc
-} // distribution
+        } // align_alloc
+} // distribution
+
+forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );