メインページ | アルファベット順一覧 | データ構造 | ファイル一覧 | データフィールド | グローバル | 関連ページ

# malloc.c

説明を見る。

    00001
    00008 #include "malloc.h"
    00009 #include "memory.h"
    00010
    00011 DKCSTD_MALLOC_STATE dkcstd_malloc_state_obj;
    00012
    00013 #define STATE dkcstd_malloc_state_obj
    00014
    00015
    00016 DKCSTD_MALLOC_STATE *dkcstd_malloc_init(size_t init_size,size_t expand_size){
    00017     STATE.init_size = init_size;
    00018     STATE.expand_size = expand_size;
    00019     STATE.alloc_count = 0;
    00020
    00021     return &STATE;
    00022 }
    00023
    00024 int dkcstd_malloc_end(){
    00025     int r;
    00026     if(STATE.alloc_count != 0){
    00027         r = -1;
    00028     }
    00029
    00030     return r;
    00031 }
    00032
    00033 DKCSTD_MALLOC_STATE *dkcstd_get_malloc_state(){
    00034     return &STATE;
    00035 }
    00036
    00037
    00038
    00039
    00040 void *dkcstd_malloc( size_t size){
    00041     if(0==size){
    00042         return NULL;
    00043     }
    00044     return dkcstdMALLOC_BASE(size);
    00045 }
    00046
    00047 void dkcstd_free(void *p){
    00048     dkcstdFREE_BASE(p);
    00049 }
    00050
    00051
    00052 void *dkcstd_realloc( void *memblock, size_t size ){
    00053     if(NULL==memblock){
    00054         return dkcstd_malloc(size);
    00055     }
    00056     return dkcstdREALLOC_BASE(memblock,size);
    00057 }
    00058
    00059
    00060
    00061 static DKC_INLINE void *aligned_malloc_calc(void *a){
    00062     BYTE *p = (BYTE *)a;
    00063     uint32 *op,*base = (uint32 *)p;
    00064     //assert(sizeof(uint32 *) == sizeof(void *));
    00065
    00066
    00067     p += sizeof(void *);
    00068     p = dkcstd_pointer_align(p,dkcstdMALLOC_MEMORY_ALIGN);
    00069
    00070     //最初のアドレスを保存
    00071     op = (uint32 *)( (BYTE *)(p - sizeof(void *)) );
    00072     *op = (uint32)base;
    00073     return p;
    00074 }
    00075
    00076 static DKC_INLINE void *aligned_free_calc(void *a){
    00077     BYTE *p = a;
    00078     uint32 *pb;
    00079     void *f;
    00080     pb = (uint32 *)( (BYTE *)(p - sizeof(void *)) );
    00081     f = (void *)(*pb);//ただのpbになっていた。○|￣|_
    00082     return f;
    00083 }
    00084
    00085 void *dkcstd_aligned_malloc(size_t size){
    00086     size_t ss = size +  dkcstdMALLOC_MEMORY_ALIGN + sizeof(void *);
    00087     void *p = dkcstd_malloc(ss);
    00088
    00089
    00090     if(NULL==p){
    00091         return NULL;
    00092     }
    00093     p = aligned_malloc_calc(p);
    00094
    00095     return p;
    00096 }
    00097
    00098
    00099 void dkcstd_aligned_free(void *a){
    00100     a = aligned_free_calc(a);
    00101     dkcstd_free(a);
    00102 }
    00103
    00104 void *dkcstd_aligned_realloc(void *memblock,size_t size){
    00105     void *p;
    00106     //if(memblock){
    00107         memblock = aligned_free_calc(memblock);
    00108         p = dkcstd_realloc(memblock,size);
    00109         p = aligned_malloc_calc(p);
    00110     //}else{
    00111     //  p = aligned_malloc(size);
    00112     //}
    00113     return p;
    00114 }
    00115
    00116
    00117 #undef STATE
    00118
    00119
    00120
    00121
    00122