00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 #include <stdio.h>
00088 #include <stdlib.h>
00089 #include <string.h>
00090 #include <assert.h>
00091 #include <stdarg.h>
00092
00093 #ifdef _MSC_VER
00094 #pragma warning (disable: 4996)
00095 #endif
00096
00097 #include "ckd_alloc.h"
00098 #include "err.h"
00099
00105 static jmp_buf *ckd_target;
00106 static int jmp_abort;
00107
00108 jmp_buf *
00109 ckd_set_jump(jmp_buf *env, int abort)
00110 {
00111 jmp_buf *old;
00112
00113 if (abort)
00114 jmp_abort = 1;
00115
00116 old = ckd_target;
00117 ckd_target = env;
00118 return old;
00119 }
00120
00121 void
00122 ckd_fail(char *format, ...)
00123 {
00124 va_list args;
00125
00126 va_start(args, format);
00127 vfprintf(stderr, format, args);
00128 va_end(args);
00129
00130 if (jmp_abort)
00131
00132 #if defined(_WIN32_WCE)
00133 exit(-1);
00134 #else
00135 abort();
00136 #endif
00137 else if (ckd_target)
00138 longjmp(*ckd_target, 1);
00139 else
00140 exit(-1);
00141 }
00142
00143 void *
00144 __ckd_calloc__(size_t n_elem, size_t elem_size,
00145 const char *caller_file, int caller_line)
00146 {
00147 void *mem;
00148
00149 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00150 if ((mem = heap_calloc(heap_lookup(1),n_elem, elem_size)) == NULL)
00151 if ((mem = heap_calloc(heap_lookup(0),n_elem, elem_size)) == NULL)
00152 {
00153 ckd_fail("calloc(%d,%d) failed from %s(%d), free space: %d\n", n_elem,
00154 elem_size, caller_file, caller_line,space_unused());
00155 }
00156 #else
00157 if ((mem = calloc(n_elem, elem_size)) == NULL) {
00158 ckd_fail("calloc(%d,%d) failed from %s(%d)\n", n_elem,
00159 elem_size, caller_file, caller_line);
00160 }
00161 #endif
00162
00163
00164 return mem;
00165 }
00166
00167
00168 void *
00169 __ckd_malloc__(size_t size, const char *caller_file, int caller_line)
00170 {
00171 void *mem;
00172
00173 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00174 if ((mem = heap_malloc(heap_lookup(0),size)) == NULL)
00175 if ((mem = heap_malloc(heap_lookup(1),size)) == NULL)
00176 #else
00177 if ((mem = malloc(size)) == NULL)
00178 #endif
00179 ckd_fail("malloc(%d) failed from %s(%d)\n", size,
00180 caller_file, caller_line);
00181
00182 return mem;
00183 }
00184
00185
00186 void *
00187 __ckd_realloc__(void *ptr, size_t new_size,
00188 const char *caller_file, int caller_line)
00189 {
00190 void *mem;
00191 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00192 if ((mem = heap_realloc(heap_lookup(0),ptr, new_size)) == NULL) {
00193 #else
00194 if ((mem = realloc(ptr, new_size)) == NULL) {
00195 #endif
00196 ckd_fail("malloc(%d) failed from %s(%d)\n", new_size,
00197 caller_file, caller_line);
00198 }
00199
00200 return mem;
00201 }
00202
00203
00204 char *
00205 __ckd_salloc__(const char *orig, const char *caller_file,
00206 int caller_line)
00207 {
00208 size_t len;
00209 char *buf;
00210
00211 len = strlen(orig) + 1;
00212 buf = (char *) __ckd_malloc__(len, caller_file, caller_line);
00213
00214 strcpy(buf, orig);
00215 return (buf);
00216 }
00217
00218
00219 void *
00220 __ckd_calloc_2d__(size_t d1, size_t d2, size_t elemsize,
00221 const char *caller_file, int caller_line)
00222 {
00223 char **ref, *mem;
00224 size_t i, offset;
00225
00226 mem =
00227 (char *) __ckd_calloc__(d1 * d2, elemsize, caller_file,
00228 caller_line);
00229 ref =
00230 (char **) __ckd_malloc__(d1 * sizeof(void *), caller_file,
00231 caller_line);
00232
00233 for (i = 0, offset = 0; i < d1; i++, offset += d2 * elemsize)
00234 ref[i] = mem + offset;
00235
00236 return ref;
00237 }
00238
00239
00240 void
00241 ckd_free(void *ptr)
00242 {
00243 if (ptr)
00244 #if defined(__ADSPBLACKFIN__) && !defined(__linux__)
00245 heap_free(0,ptr);
00246 #else
00247 free(ptr);
00248 #endif
00249 }
00250
00251 void
00252 ckd_free_2d(void *tmpptr)
00253 {
00254 void **ptr = (void **)tmpptr;
00255 if (ptr)
00256 ckd_free(ptr[0]);
00257 ckd_free(ptr);
00258 }
00259
00260
00261 void *
00262 __ckd_calloc_3d__(size_t d1, size_t d2, size_t d3, size_t elemsize,
00263 const char *caller_file, int caller_line)
00264 {
00265 char ***ref1, **ref2, *mem;
00266 size_t i, j, offset;
00267
00268 mem =
00269 (char *) __ckd_calloc__(d1 * d2 * d3, elemsize, caller_file,
00270 caller_line);
00271 ref1 =
00272 (char ***) __ckd_malloc__(d1 * sizeof(void **), caller_file,
00273 caller_line);
00274 ref2 =
00275 (char **) __ckd_malloc__(d1 * d2 * sizeof(void *), caller_file,
00276 caller_line);
00277
00278 for (i = 0, offset = 0; i < d1; i++, offset += d2)
00279 ref1[i] = ref2 + offset;
00280
00281 offset = 0;
00282 for (i = 0; i < d1; i++) {
00283 for (j = 0; j < d2; j++) {
00284 ref1[i][j] = mem + offset;
00285 offset += d3 * elemsize;
00286 }
00287 }
00288
00289 return ref1;
00290 }
00291
00292
00293 void
00294 ckd_free_3d(void *inptr)
00295 {
00296 void ***ptr = (void ***)inptr;
00297
00298 if (ptr && ptr[0])
00299 ckd_free(ptr[0][0]);
00300 if (ptr)
00301 ckd_free(ptr[0]);
00302 ckd_free(ptr);
00303 }
00304
00305
00306 void *
00307 __ckd_alloc_3d_ptr(size_t d1,
00308 size_t d2,
00309 size_t d3,
00310 void *store,
00311 size_t elem_size,
00312 char *file,
00313 int line)
00314 {
00315 void **tmp1;
00316 void ***out;
00317 size_t i, j;
00318
00319 tmp1 = __ckd_calloc__(d1 * d2, sizeof(void *), file, line);
00320
00321 out = __ckd_calloc__(d1, sizeof(void **), file, line);
00322
00323 for (i = 0, j = 0; i < d1*d2; i++, j += d3) {
00324 tmp1[i] = &((char *)store)[j*elem_size];
00325 }
00326
00327 for (i = 0, j = 0; i < d1; i++, j += d2) {
00328 out[i] = &tmp1[j];
00329 }
00330
00331 return out;
00332 }
00333
00334 void *
00335 __ckd_alloc_2d_ptr(size_t d1,
00336 size_t d2,
00337 void *store,
00338 size_t elem_size,
00339 char *file,
00340 int line)
00341 {
00342 void **out;
00343 size_t i, j;
00344
00345 out = __ckd_calloc__(d1, sizeof(void *), file, line);
00346
00347 for (i = 0, j = 0; i < d1; i++, j += d2) {
00348 out[i] = &((char *)store)[j*elem_size];
00349 }
00350
00351 return out;
00352 }