| 1 |
|
| 2 |
|
| 3 |
/****************************************************************** |
| 4 |
|
| 5 |
AmigaOS-specific routines for GC. |
| 6 |
This file is normally included from os_dep.c |
| 7 |
|
| 8 |
******************************************************************/ |
| 9 |
|
| 10 |
|
| 11 |
#if !defined(GC_AMIGA_DEF) && !defined(GC_AMIGA_SB) && !defined(GC_AMIGA_DS) && !defined(GC_AMIGA_AM) |
| 12 |
# include "private/gc_priv.h" |
| 13 |
# include <stdio.h> |
| 14 |
# include <signal.h> |
| 15 |
# define GC_AMIGA_DEF |
| 16 |
# define GC_AMIGA_SB |
| 17 |
# define GC_AMIGA_DS |
| 18 |
# define GC_AMIGA_AM |
| 19 |
#endif |
| 20 |
|
| 21 |
|
| 22 |
#ifdef GC_AMIGA_DEF |
| 23 |
|
| 24 |
# ifndef __GNUC__ |
| 25 |
# include <exec/exec.h> |
| 26 |
# endif |
| 27 |
# include <proto/exec.h> |
| 28 |
# include <proto/dos.h> |
| 29 |
# include <dos/dosextens.h> |
| 30 |
# include <workbench/startup.h> |
| 31 |
|
| 32 |
#endif |
| 33 |
|
| 34 |
|
| 35 |
|
| 36 |
|
| 37 |
#ifdef GC_AMIGA_SB |
| 38 |
|
| 39 |
/****************************************************************** |
| 40 |
Find the base of the stack. |
| 41 |
******************************************************************/ |
| 42 |
|
| 43 |
ptr_t GC_get_main_stack_base(void) |
| 44 |
{ |
| 45 |
struct Process *proc = (struct Process*)SysBase->ThisTask; |
| 46 |
|
| 47 |
/* Reference: Amiga Guru Book Pages: 42,567,574 */ |
| 48 |
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS |
| 49 |
&& proc->pr_CLI != NULL) { |
| 50 |
/* first ULONG is StackSize */ |
| 51 |
/*longPtr = proc->pr_ReturnAddr; |
| 52 |
size = longPtr[0];*/ |
| 53 |
|
| 54 |
return (char *)proc->pr_ReturnAddr + sizeof(ULONG); |
| 55 |
} else { |
| 56 |
return (char *)proc->pr_Task.tc_SPUpper; |
| 57 |
} |
| 58 |
} |
| 59 |
|
| 60 |
#endif |
| 61 |
|
| 62 |
|
| 63 |
#ifdef GC_AMIGA_DS |
| 64 |
/****************************************************************** |
| 65 |
Register data segments. |
| 66 |
******************************************************************/ |
| 67 |
|
| 68 |
void GC_register_data_segments(void) |
| 69 |
{ |
| 70 |
struct Process *proc; |
| 71 |
struct CommandLineInterface *cli; |
| 72 |
BPTR myseglist; |
| 73 |
ULONG *data; |
| 74 |
|
| 75 |
# ifdef __GNUC__ |
| 76 |
ULONG dataSegSize; |
| 77 |
GC_bool found_segment = FALSE; |
| 78 |
extern char __data_size[]; |
| 79 |
|
| 80 |
dataSegSize=__data_size+8; |
| 81 |
/* Can`t find the Location of __data_size, because |
| 82 |
it`s possible that is it, inside the segment. */ |
| 83 |
|
| 84 |
# endif |
| 85 |
|
| 86 |
proc= (struct Process*)SysBase->ThisTask; |
| 87 |
|
| 88 |
/* Reference: Amiga Guru Book Pages: 538ff,565,573 |
| 89 |
and XOper.asm */ |
| 90 |
myseglist = proc->pr_SegList; |
| 91 |
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) { |
| 92 |
if (proc->pr_CLI != NULL) { |
| 93 |
/* ProcLoaded 'Loaded as a command: '*/ |
| 94 |
cli = BADDR(proc->pr_CLI); |
| 95 |
myseglist = cli->cli_Module; |
| 96 |
} |
| 97 |
} else { |
| 98 |
ABORT("Not a Process."); |
| 99 |
} |
| 100 |
|
| 101 |
if (myseglist == NULL) { |
| 102 |
ABORT("Arrrgh.. can't find segments, aborting"); |
| 103 |
} |
| 104 |
|
| 105 |
/* xoper hunks Shell Process */ |
| 106 |
|
| 107 |
for (data = (ULONG *)BADDR(myseglist); data != NULL; |
| 108 |
data = (ULONG *)BADDR(data[0])) { |
| 109 |
if ((ULONG)GC_register_data_segments < (ULONG)(&data[1]) |
| 110 |
|| (ULONG)GC_register_data_segments > (ULONG)(&data[1]) |
| 111 |
+ data[-1]) { |
| 112 |
# ifdef __GNUC__ |
| 113 |
if (dataSegSize == data[-1]) { |
| 114 |
found_segment = TRUE; |
| 115 |
} |
| 116 |
# endif |
| 117 |
GC_add_roots_inner((char *)&data[1], |
| 118 |
((char *)&data[1]) + data[-1], FALSE); |
| 119 |
} |
| 120 |
} /* for */ |
| 121 |
# ifdef __GNUC__ |
| 122 |
if (!found_segment) { |
| 123 |
ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library"); |
| 124 |
} |
| 125 |
# endif |
| 126 |
} |
| 127 |
|
| 128 |
#endif |
| 129 |
|
| 130 |
|
| 131 |
|
| 132 |
#ifdef GC_AMIGA_AM |
| 133 |
|
| 134 |
#ifndef GC_AMIGA_FASTALLOC |
| 135 |
|
| 136 |
void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){ |
| 137 |
return (*AllocFunction)(size); |
| 138 |
} |
| 139 |
|
| 140 |
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2)) |
| 141 |
=GC_amiga_allocwrapper; |
| 142 |
|
| 143 |
#else |
| 144 |
|
| 145 |
|
| 146 |
|
| 147 |
|
| 148 |
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)); |
| 149 |
|
| 150 |
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2)) |
| 151 |
=GC_amiga_allocwrapper_firsttime; |
| 152 |
|
| 153 |
|
| 154 |
/****************************************************************** |
| 155 |
Amiga-specific routines to obtain memory, and force GC to give |
| 156 |
back fast-mem whenever possible. |
| 157 |
These hacks makes gc-programs go many times faster when |
| 158 |
the Amiga is low on memory, and are therefore strictly necessary. |
| 159 |
|
| 160 |
-Kjetil S. Matheussen, 2000. |
| 161 |
******************************************************************/ |
| 162 |
|
| 163 |
|
| 164 |
|
| 165 |
/* List-header for all allocated memory. */ |
| 166 |
|
| 167 |
struct GC_Amiga_AllocedMemoryHeader{ |
| 168 |
ULONG size; |
| 169 |
struct GC_Amiga_AllocedMemoryHeader *next; |
| 170 |
}; |
| 171 |
struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL); |
| 172 |
|
| 173 |
|
| 174 |
|
| 175 |
/* Type of memory. Once in the execution of a program, this might change to MEMF_ANY|MEMF_CLEAR */ |
| 176 |
|
| 177 |
ULONG GC_AMIGA_MEMF = MEMF_FAST | MEMF_CLEAR; |
| 178 |
|
| 179 |
|
| 180 |
/* Prevents GC_amiga_get_mem from allocating memory if this one is TRUE. */ |
| 181 |
#ifndef GC_AMIGA_ONLYFAST |
| 182 |
BOOL GC_amiga_dontalloc=FALSE; |
| 183 |
#endif |
| 184 |
|
| 185 |
#ifdef GC_AMIGA_PRINTSTATS |
| 186 |
int succ=0,succ2=0; |
| 187 |
int nsucc=0,nsucc2=0; |
| 188 |
int nullretries=0; |
| 189 |
int numcollects=0; |
| 190 |
int chipa=0; |
| 191 |
int allochip=0; |
| 192 |
int allocfast=0; |
| 193 |
int cur0=0; |
| 194 |
int cur1=0; |
| 195 |
int cur10=0; |
| 196 |
int cur50=0; |
| 197 |
int cur150=0; |
| 198 |
int cur151=0; |
| 199 |
int ncur0=0; |
| 200 |
int ncur1=0; |
| 201 |
int ncur10=0; |
| 202 |
int ncur50=0; |
| 203 |
int ncur150=0; |
| 204 |
int ncur151=0; |
| 205 |
#endif |
| 206 |
|
| 207 |
/* Free everything at program-end. */ |
| 208 |
|
| 209 |
void GC_amiga_free_all_mem(void){ |
| 210 |
struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM)); |
| 211 |
|
| 212 |
#ifdef GC_AMIGA_PRINTSTATS |
| 213 |
printf("\n\n" |
| 214 |
"%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n", |
| 215 |
allochip,allocfast |
| 216 |
); |
| 217 |
printf( |
| 218 |
"%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n", |
| 219 |
chipa |
| 220 |
); |
| 221 |
printf("\n"); |
| 222 |
printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects); |
| 223 |
printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries); |
| 224 |
printf("\n"); |
| 225 |
printf("Succeeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2); |
| 226 |
printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2); |
| 227 |
printf("\n"); |
| 228 |
printf( |
| 229 |
"Number of retries before succeeding a chip->fast force:\n" |
| 230 |
"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n", |
| 231 |
cur0,cur1,cur10,cur50,cur150,cur151 |
| 232 |
); |
| 233 |
printf( |
| 234 |
"Number of retries before giving up a chip->fast force:\n" |
| 235 |
"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n", |
| 236 |
ncur0,ncur1,ncur10,ncur50,ncur150,ncur151 |
| 237 |
); |
| 238 |
#endif |
| 239 |
|
| 240 |
while(gc_am!=NULL){ |
| 241 |
struct GC_Amiga_AllocedMemoryHeader *temp = gc_am->next; |
| 242 |
FreeMem(gc_am,gc_am->size); |
| 243 |
gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp)); |
| 244 |
} |
| 245 |
} |
| 246 |
|
| 247 |
#ifndef GC_AMIGA_ONLYFAST |
| 248 |
|
| 249 |
/* All memory with address lower than this one is chip-mem. */ |
| 250 |
|
| 251 |
char *chipmax; |
| 252 |
|
| 253 |
|
| 254 |
/* |
| 255 |
* Always set to the last size of memory tried to be allocated. |
| 256 |
* Needed to ensure allocation when the size is bigger than 100000. |
| 257 |
* |
| 258 |
*/ |
| 259 |
size_t latestsize; |
| 260 |
|
| 261 |
#endif |
| 262 |
|
| 263 |
|
| 264 |
#ifdef GC_AMIGA_FASTALLOC |
| 265 |
|
| 266 |
/* |
| 267 |
* The actual function that is called with the GET_MEM macro. |
| 268 |
* |
| 269 |
*/ |
| 270 |
|
| 271 |
void *GC_amiga_get_mem(size_t size){ |
| 272 |
struct GC_Amiga_AllocedMemoryHeader *gc_am; |
| 273 |
|
| 274 |
#ifndef GC_AMIGA_ONLYFAST |
| 275 |
if(GC_amiga_dontalloc==TRUE){ |
| 276 |
return NULL; |
| 277 |
} |
| 278 |
|
| 279 |
/* We really don't want to use chip-mem, but if we must, then as little as possible. */ |
| 280 |
if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL; |
| 281 |
#endif |
| 282 |
|
| 283 |
gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF); |
| 284 |
if(gc_am==NULL) return NULL; |
| 285 |
|
| 286 |
gc_am->next=GC_AMIGAMEM; |
| 287 |
gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader); |
| 288 |
GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am)); |
| 289 |
|
| 290 |
#ifdef GC_AMIGA_PRINTSTATS |
| 291 |
if((char *)gc_am<chipmax){ |
| 292 |
allochip+=size; |
| 293 |
}else{ |
| 294 |
allocfast+=size; |
| 295 |
} |
| 296 |
#endif |
| 297 |
|
| 298 |
return gc_am+1; |
| 299 |
|
| 300 |
} |
| 301 |
|
| 302 |
#endif |
| 303 |
|
| 304 |
|
| 305 |
#ifndef GC_AMIGA_ONLYFAST |
| 306 |
|
| 307 |
/* Tries very hard to force GC to find fast-mem to return. Done recursively |
| 308 |
* to hold the rejected memory-pointers reachable from the collector in an |
| 309 |
* easy way. |
| 310 |
* |
| 311 |
*/ |
| 312 |
#ifdef GC_AMIGA_RETRY |
| 313 |
void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const int rec){ |
| 314 |
void *ret; |
| 315 |
|
| 316 |
ret=(*AllocFunction)(size); |
| 317 |
|
| 318 |
#ifdef GC_AMIGA_PRINTSTATS |
| 319 |
if((char *)ret>chipmax || ret==NULL){ |
| 320 |
if(ret==NULL){ |
| 321 |
nsucc++; |
| 322 |
nsucc2+=size; |
| 323 |
if(rec==0) ncur0++; |
| 324 |
if(rec==1) ncur1++; |
| 325 |
if(rec>1 && rec<10) ncur10++; |
| 326 |
if(rec>=10 && rec<50) ncur50++; |
| 327 |
if(rec>=50 && rec<150) ncur150++; |
| 328 |
if(rec>=150) ncur151++; |
| 329 |
}else{ |
| 330 |
succ++; |
| 331 |
succ2+=size; |
| 332 |
if(rec==0) cur0++; |
| 333 |
if(rec==1) cur1++; |
| 334 |
if(rec>1 && rec<10) cur10++; |
| 335 |
if(rec>=10 && rec<50) cur50++; |
| 336 |
if(rec>=50 && rec<150) cur150++; |
| 337 |
if(rec>=150) cur151++; |
| 338 |
} |
| 339 |
} |
| 340 |
#endif |
| 341 |
|
| 342 |
if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){ |
| 343 |
ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1); |
| 344 |
} |
| 345 |
|
| 346 |
return ret; |
| 347 |
} |
| 348 |
#endif |
| 349 |
|
| 350 |
|
| 351 |
/* The allocating-functions defined inside the Amiga-blocks in gc.h is called |
| 352 |
* via these functions. |
| 353 |
*/ |
| 354 |
|
| 355 |
|
| 356 |
void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){ |
| 357 |
void *ret; |
| 358 |
|
| 359 |
GC_amiga_dontalloc=TRUE; /* Pretty tough thing to do, but it's indeed necessary. */ |
| 360 |
latestsize=size; |
| 361 |
|
| 362 |
ret=(*AllocFunction)(size); |
| 363 |
|
| 364 |
if(((char *)ret) <= chipmax){ |
| 365 |
if(ret==NULL){ |
| 366 |
/* Give GC access to allocate memory. */ |
| 367 |
#ifdef GC_AMIGA_GC |
| 368 |
if(!GC_dont_gc){ |
| 369 |
GC_gcollect(); |
| 370 |
#ifdef GC_AMIGA_PRINTSTATS |
| 371 |
numcollects++; |
| 372 |
#endif |
| 373 |
ret=(*AllocFunction)(size); |
| 374 |
} |
| 375 |
if(ret==NULL) |
| 376 |
#endif |
| 377 |
{ |
| 378 |
GC_amiga_dontalloc=FALSE; |
| 379 |
ret=(*AllocFunction)(size); |
| 380 |
if(ret==NULL){ |
| 381 |
WARN("Out of Memory! Returning NIL!\n", 0); |
| 382 |
} |
| 383 |
} |
| 384 |
#ifdef GC_AMIGA_PRINTSTATS |
| 385 |
else{ |
| 386 |
nullretries++; |
| 387 |
} |
| 388 |
if(ret!=NULL && (char *)ret<=chipmax) chipa+=size; |
| 389 |
#endif |
| 390 |
} |
| 391 |
#ifdef GC_AMIGA_RETRY |
| 392 |
else{ |
| 393 |
void *ret2; |
| 394 |
/* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */ |
| 395 |
/* Using gctest to check the effectiveness of doing this, does seldom give a very good result. */ |
| 396 |
/* However, real programs doesn't normally rapidly allocate and deallocate. */ |
| 397 |
if( |
| 398 |
AllocFunction!=GC_malloc_uncollectable |
| 399 |
#ifdef GC_ATOMIC_UNCOLLECTABLE |
| 400 |
&& AllocFunction!=GC_malloc_atomic_uncollectable |
| 401 |
#endif |
| 402 |
){ |
| 403 |
ret2=GC_amiga_rec_alloc(size,AllocFunction,0); |
| 404 |
}else{ |
| 405 |
ret2=(*AllocFunction)(size); |
| 406 |
#ifdef GC_AMIGA_PRINTSTATS |
| 407 |
if((char *)ret2<chipmax || ret2==NULL){ |
| 408 |
nsucc++; |
| 409 |
nsucc2+=size; |
| 410 |
ncur0++; |
| 411 |
}else{ |
| 412 |
succ++; |
| 413 |
succ2+=size; |
| 414 |
cur0++; |
| 415 |
} |
| 416 |
#endif |
| 417 |
} |
| 418 |
if(((char *)ret2)>chipmax){ |
| 419 |
GC_free(ret); |
| 420 |
ret=ret2; |
| 421 |
}else{ |
| 422 |
GC_free(ret2); |
| 423 |
} |
| 424 |
} |
| 425 |
#endif |
| 426 |
} |
| 427 |
|
| 428 |
# if defined(CPPCHECK) |
| 429 |
if (GC_amiga_dontalloc) /* variable is actually used by AllocFunction */ |
| 430 |
# endif |
| 431 |
GC_amiga_dontalloc=FALSE; |
| 432 |
|
| 433 |
return ret; |
| 434 |
} |
| 435 |
|
| 436 |
|
| 437 |
|
| 438 |
void (*GC_amiga_toany)(void)=NULL; |
| 439 |
|
| 440 |
void GC_amiga_set_toany(void (*func)(void)){ |
| 441 |
GC_amiga_toany=func; |
| 442 |
} |
| 443 |
|
| 444 |
#endif /* !GC_AMIGA_ONLYFAST */ |
| 445 |
|
| 446 |
|
| 447 |
void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){ |
| 448 |
void *ret; |
| 449 |
|
| 450 |
ret=(*AllocFunction)(size); |
| 451 |
|
| 452 |
if(ret==NULL){ |
| 453 |
/* Enable chip-mem allocation. */ |
| 454 |
#ifdef GC_AMIGA_GC |
| 455 |
if(!GC_dont_gc){ |
| 456 |
GC_gcollect(); |
| 457 |
#ifdef GC_AMIGA_PRINTSTATS |
| 458 |
numcollects++; |
| 459 |
#endif |
| 460 |
ret=(*AllocFunction)(size); |
| 461 |
} |
| 462 |
if(ret==NULL) |
| 463 |
#endif |
| 464 |
{ |
| 465 |
#ifndef GC_AMIGA_ONLYFAST |
| 466 |
GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR; |
| 467 |
if(GC_amiga_toany!=NULL) (*GC_amiga_toany)(); |
| 468 |
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any; |
| 469 |
return GC_amiga_allocwrapper_any(size,AllocFunction); |
| 470 |
#endif |
| 471 |
} |
| 472 |
#ifdef GC_AMIGA_PRINTSTATS |
| 473 |
else{ |
| 474 |
nullretries++; |
| 475 |
} |
| 476 |
#endif |
| 477 |
} |
| 478 |
|
| 479 |
return ret; |
| 480 |
} |
| 481 |
|
| 482 |
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){ |
| 483 |
atexit(&GC_amiga_free_all_mem); |
| 484 |
chipmax=(char *)SysBase->MaxLocMem; /* For people still having SysBase in chip-mem, this might speed up a bit. */ |
| 485 |
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast; |
| 486 |
return GC_amiga_allocwrapper_fast(size,AllocFunction); |
| 487 |
} |
| 488 |
|
| 489 |
|
| 490 |
#endif /* GC_AMIGA_FASTALLOC */ |
| 491 |
|
| 492 |
|
| 493 |
|
| 494 |
/* |
| 495 |
* The wrapped realloc function. |
| 496 |
* |
| 497 |
*/ |
| 498 |
void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){ |
| 499 |
#ifndef GC_AMIGA_FASTALLOC |
| 500 |
return GC_realloc(old_object,new_size_in_bytes); |
| 501 |
#else |
| 502 |
void *ret; |
| 503 |
latestsize=new_size_in_bytes; |
| 504 |
ret=GC_realloc(old_object,new_size_in_bytes); |
| 505 |
if(ret==NULL && new_size_in_bytes != 0 |
| 506 |
&& GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){ |
| 507 |
/* Out of fast-mem. */ |
| 508 |
#ifdef GC_AMIGA_GC |
| 509 |
if(!GC_dont_gc){ |
| 510 |
GC_gcollect(); |
| 511 |
#ifdef GC_AMIGA_PRINTSTATS |
| 512 |
numcollects++; |
| 513 |
#endif |
| 514 |
ret=GC_realloc(old_object,new_size_in_bytes); |
| 515 |
} |
| 516 |
if(ret==NULL) |
| 517 |
#endif |
| 518 |
{ |
| 519 |
#ifndef GC_AMIGA_ONLYFAST |
| 520 |
GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR; |
| 521 |
if(GC_amiga_toany!=NULL) (*GC_amiga_toany)(); |
| 522 |
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any; |
| 523 |
ret=GC_realloc(old_object,new_size_in_bytes); |
| 524 |
#endif |
| 525 |
} |
| 526 |
#ifdef GC_AMIGA_PRINTSTATS |
| 527 |
else{ |
| 528 |
nullretries++; |
| 529 |
} |
| 530 |
#endif |
| 531 |
} |
| 532 |
if(ret==NULL && new_size_in_bytes != 0){ |
| 533 |
WARN("Out of Memory! Returning NIL!\n", 0); |
| 534 |
} |
| 535 |
#ifdef GC_AMIGA_PRINTSTATS |
| 536 |
if(((char *)ret)<chipmax && ret!=NULL){ |
| 537 |
chipa+=new_size_in_bytes; |
| 538 |
} |
| 539 |
#endif |
| 540 |
return ret; |
| 541 |
#endif |
| 542 |
} |
| 543 |
|
| 544 |
#endif /* GC_AMIGA_AM */ |