URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [boehm-gc/] [AmigaOS.c] - Blame information for rev 746

Go to most recent revision | Details | Compare with Previous | View Log


 
 
/******************************************************************
 
  AmigaOS-spesific routines for GC.
  This file is normally included from os_dep.c
 
******************************************************************/
 
 
#if !defined(GC_AMIGA_DEF) && !defined(GC_AMIGA_SB) && !defined(GC_AMIGA_DS) && !defined(GC_AMIGA_AM)
# include "gc_priv.h"
# include <stdio.h>
# include <signal.h>
# define GC_AMIGA_DEF
# define GC_AMIGA_SB
# define GC_AMIGA_DS
# define GC_AMIGA_AM
#endif
 
 
#ifdef GC_AMIGA_DEF
 
# ifndef __GNUC__
#   include <exec/exec.h>
# endif
# include <proto/exec.h>
# include <proto/dos.h>
# include <dos/dosextens.h>
# include <workbench/startup.h>
 
#endif
 
 
 
 
#ifdef GC_AMIGA_SB
 
/******************************************************************
   Find the base of the stack.
******************************************************************/
 
ptr_t GC_get_stack_base()
{
    struct Process *proc = (struct Process*)SysBase->ThisTask;
 
    /* Reference: Amiga Guru Book Pages: 42,567,574 */
    if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS
        && proc->pr_CLI != NULL) {
        /* first ULONG is StackSize */
        /*longPtr = proc->pr_ReturnAddr;
        size = longPtr[0];*/
 
        return (char *)proc->pr_ReturnAddr + sizeof(ULONG);
    } else {
        return (char *)proc->pr_Task.tc_SPUpper;
    }
}
 
#if 0 /* old version */
ptr_t GC_get_stack_base()
{
    extern struct WBStartup *_WBenchMsg;
    extern long __base;
    extern long __stack;
    struct Task *task;
    struct Process *proc;
    struct CommandLineInterface *cli;
    long size;
 
    if ((task = FindTask(0)) == 0) {
        GC_err_puts("Cannot find own task structure\n");
        ABORT("task missing");
    }
    proc = (struct Process *)task;
    cli = BADDR(proc->pr_CLI);
 
    if (_WBenchMsg != 0 || cli == 0) {
        size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
    } else {
        size = cli->cli_DefaultStack * 4;
    }
    return (ptr_t)(__base + GC_max(size, __stack));
}
#endif
 
 
#endif
 
 
#ifdef GC_AMIGA_DS
/******************************************************************
   Register data segments.
******************************************************************/
 
   void GC_register_data_segments()
   {
     struct Process     *proc;
     struct CommandLineInterface *cli;
     BPTR myseglist;
     ULONG *data;
 
     int        num;
 
 
#    ifdef __GNUC__
        ULONG dataSegSize;
        GC_bool found_segment = FALSE;
        extern char __data_size[];
 
        dataSegSize=__data_size+8;
        /* Can`t find the Location of __data_size, because
           it`s possible that is it, inside the segment. */
 
#     endif
 
        proc= (struct Process*)SysBase->ThisTask;
 
        /* Reference: Amiga Guru Book Pages: 538ff,565,573
                     and XOper.asm */
        if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) {
          if (proc->pr_CLI == NULL) {
            myseglist = proc->pr_SegList;
          } else {
            /* ProcLoaded       'Loaded as a command: '*/
            cli = BADDR(proc->pr_CLI);
            myseglist = cli->cli_Module;
          }
        } else {
          ABORT("Not a Process.");
        }
 
        if (myseglist == NULL) {
            ABORT("Arrrgh.. can't find segments, aborting");
        }
 
        /* xoper hunks Shell Process */
 
        num=0;
        for (data = (ULONG *)BADDR(myseglist); data != NULL;
             data = (ULONG *)BADDR(data[0])) {
          if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
              ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
#             ifdef __GNUC__
                if (dataSegSize == data[-1]) {
                  found_segment = TRUE;
                }
#             endif
              GC_add_roots_inner((char *)&data[1],
                                 ((char *)&data[1]) + data[-1], FALSE);
          }
          ++num;
        } /* for */
#       ifdef __GNUC__
           if (!found_segment) {
             ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
           }
#       endif
  }
 
#if 0 /* old version */
  void GC_register_data_segments()
  {
    extern struct WBStartup *_WBenchMsg;
    struct Process      *proc;
    struct CommandLineInterface *cli;
    BPTR myseglist;
    ULONG *data;
 
    if ( _WBenchMsg != 0 ) {
        if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
            GC_err_puts("No seglist from workbench\n");
            return;
        }
    } else {
        if ((proc = (struct Process *)FindTask(0)) == 0) {
            GC_err_puts("Cannot find process structure\n");
            return;
        }
        if ((cli = BADDR(proc->pr_CLI)) == 0) {
            GC_err_puts("No CLI\n");
            return;
        }
        if ((myseglist = cli->cli_Module) == 0) {
            GC_err_puts("No seglist from CLI\n");
            return;
        }
    }
 
    for (data = (ULONG *)BADDR(myseglist); data != 0;
         data = (ULONG *)BADDR(data[0])) {
#        ifdef AMIGA_SKIP_SEG
           if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
           ((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
#        else
           {
#        endif /* AMIGA_SKIP_SEG */
          GC_add_roots_inner((char *)&data[1],
                             ((char *)&data[1]) + data[-1], FALSE);
         }
    }
  }
#endif /* old version */
 
 
#endif
 
 
 
#ifdef GC_AMIGA_AM
 
#ifndef GC_AMIGA_FASTALLOC
 
void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){
        return (*AllocFunction)(size);
}
 
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
        =GC_amiga_allocwrapper;
 
#else
 
 
 
 
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2));
 
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
        =GC_amiga_allocwrapper_firsttime;
 
 
/******************************************************************
   Amiga-spesific routines to obtain memory, and force GC to give
   back fast-mem whenever possible.
        These hacks makes gc-programs go many times faster when
   the amiga is low on memory, and are therefore strictly necesarry.
 
   -Kjetil S. Matheussen, 2000.
******************************************************************/
 
 
 
/* List-header for all allocated memory. */
 
struct GC_Amiga_AllocedMemoryHeader{
        ULONG size;
        struct GC_Amiga_AllocedMemoryHeader *next;
};
struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL);
 
 
 
/* Type of memory. Once in the execution of a program, this might change to MEMF_ANY|MEMF_CLEAR */
 
ULONG GC_AMIGA_MEMF = MEMF_FAST | MEMF_CLEAR;
 
 
/* Prevents GC_amiga_get_mem from allocating memory if this one is TRUE. */
#ifndef GC_AMIGA_ONLYFAST
BOOL GC_amiga_dontalloc=FALSE;
#endif
 
#ifdef GC_AMIGA_PRINTSTATS
int succ=0,succ2=0;
int nsucc=0,nsucc2=0;
int nullretries=0;
int numcollects=0;
int chipa=0;
int allochip=0;
int allocfast=0;
int cur0=0;
int cur1=0;
int cur10=0;
int cur50=0;
int cur150=0;
int cur151=0;
int ncur0=0;
int ncur1=0;
int ncur10=0;
int ncur50=0;
int ncur150=0;
int ncur151=0;
#endif
 
/* Free everything at program-end. */
 
void GC_amiga_free_all_mem(void){
        struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM));
        struct GC_Amiga_AllocedMemoryHeader *temp;
 
#ifdef GC_AMIGA_PRINTSTATS
        printf("\n\n"
                "%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n",
                allochip,allocfast
        );
        printf(
                "%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
                chipa
        );
        printf("\n");
        printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
        printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
        printf("\n");
        printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2);
        printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2);
        printf("\n");
        printf(
                "Number of retries before succeding a chip->fast force:\n"
                "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
                cur0,cur1,cur10,cur50,cur150,cur151
        );
        printf(
                "Number of retries before giving up a chip->fast force:\n"
                "0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
                ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
        );
#endif
 
        while(gc_am!=NULL){
                temp=gc_am->next;
                FreeMem(gc_am,gc_am->size);
                gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp));
        }
}
 
#ifndef GC_AMIGA_ONLYFAST
 
/* All memory with address lower than this one is chip-mem. */
 
char *chipmax;
 
 
/*
 * Allways set to the last size of memory tried to be allocated.
 * Needed to ensure allocation when the size is bigger than 100000.
 *
 */
size_t latestsize;
 
#endif
 
 
/*
 * The actual function that is called with the GET_MEM macro.
 *
 */
 
void *GC_amiga_get_mem(size_t size){
        struct GC_Amiga_AllocedMemoryHeader *gc_am;
 
#ifndef GC_AMIGA_ONLYFAST
        if(GC_amiga_dontalloc==TRUE){
//              printf("rejected, size: %d, latestsize: %d\n",size,latestsize);
                return NULL;
        }
 
        // We really don't want to use chip-mem, but if we must, then as little as possible.
        if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL;
#endif
 
        gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
        if(gc_am==NULL) return NULL;
 
        gc_am->next=GC_AMIGAMEM;
        gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader);
        GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am));
 
//      printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize);
 
#ifdef GC_AMIGA_PRINTSTATS
        if((char *)gc_am<chipmax){
                allochip+=size;
        }else{
                allocfast+=size;
        }
#endif
 
        return gc_am+1;
 
}
 
 
 
 
#ifndef GC_AMIGA_ONLYFAST
 
/* Tries very hard to force GC to find fast-mem to return. Done recursively
 * to hold the rejected memory-pointers reachable from the collector in an
 * easy way.
 *
 */
#ifdef GC_AMIGA_RETRY
void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const int rec){
        void *ret;
 
        ret=(*AllocFunction)(size);
 
#ifdef GC_AMIGA_PRINTSTATS
        if((char *)ret>chipmax || ret==NULL){
                if(ret==NULL){
                        nsucc++;
                        nsucc2+=size;
                        if(rec==0) ncur0++;
                        if(rec==1) ncur1++;
                        if(rec>1 && rec<10) ncur10++;
                        if(rec>=10 && rec<50) ncur50++;
                        if(rec>=50 && rec<150) ncur150++;
                        if(rec>=150) ncur151++;
                }else{
                        succ++;
                        succ2+=size;
                        if(rec==0) cur0++;
                        if(rec==1) cur1++;
                        if(rec>1 && rec<10) cur10++;
                        if(rec>=10 && rec<50) cur50++;
                        if(rec>=50 && rec<150) cur150++;
                        if(rec>=150) cur151++;
                }
        }
#endif
 
        if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){
                ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
//              GC_free(ret2);
        }
 
        return ret;
}
#endif
 
 
/* The allocating-functions defined inside the amiga-blocks in gc.h is called
 * via these functions.
 */
 
 
void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){
        void *ret,*ret2;
 
        GC_amiga_dontalloc=TRUE;        // Pretty tough thing to do, but its indeed necesarry.
        latestsize=size;
 
        ret=(*AllocFunction)(size);
 
        if(((char *)ret) <= chipmax){
                if(ret==NULL){
                        //Give GC access to allocate memory.
#ifdef GC_AMIGA_GC
                        if(!GC_dont_gc){
                                GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
                                numcollects++;
#endif
                                ret=(*AllocFunction)(size);
                        }
#endif
                        if(ret==NULL){
                                GC_amiga_dontalloc=FALSE;
                                ret=(*AllocFunction)(size);
                                if(ret==NULL){
                                        WARN("Out of Memory!  Returning NIL!\n", 0);
                                }
                        }
#ifdef GC_AMIGA_PRINTSTATS
                        else{
                                nullretries++;
                        }
                        if(ret!=NULL && (char *)ret<=chipmax) chipa+=size;
#endif
                }
#ifdef GC_AMIGA_RETRY
                else{
                        /* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
                        /* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
                        /* However, real programs doesn't normally rapidly allocate and deallocate. */
//                      printf("trying to force... %d bytes... ",size);
                        if(
                                AllocFunction!=GC_malloc_uncollectable
#ifdef ATOMIC_UNCOLLECTABLE
                                && AllocFunction!=GC_malloc_atomic_uncollectable
#endif
                        ){
                                ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
                        }else{
                                ret2=(*AllocFunction)(size);
#ifdef GC_AMIGA_PRINTSTATS
                                if((char *)ret2<chipmax || ret2==NULL){
                                        nsucc++;
                                        nsucc2+=size;
                                        ncur0++;
                                }else{
                                        succ++;
                                        succ2+=size;
                                        cur0++;
                                }
#endif
                        }
                        if(((char *)ret2)>chipmax){
//                              printf("Succeeded.\n");
                                GC_free(ret);
                                ret=ret2;
                        }else{
                                GC_free(ret2);
//                              printf("But did not succeed.\n");
                        }
                }
#endif
        }
 
        GC_amiga_dontalloc=FALSE;
 
        return ret;
}
 
 
 
void (*GC_amiga_toany)(void)=NULL;
 
void GC_amiga_set_toany(void (*func)(void)){
        GC_amiga_toany=func;
}
 
#endif // !GC_AMIGA_ONLYFAST
 
 
void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){
        void *ret;
 
        ret=(*AllocFunction)(size);
 
        if(ret==NULL){
                // Enable chip-mem allocation.
//              printf("ret==NULL\n");
#ifdef GC_AMIGA_GC
                if(!GC_dont_gc){
                        GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
                        numcollects++;
#endif
                        ret=(*AllocFunction)(size);
                }
#endif
                if(ret==NULL){
#ifndef GC_AMIGA_ONLYFAST
                        GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
                        if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
                        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
                        return GC_amiga_allocwrapper_any(size,AllocFunction);
#endif
                }
#ifdef GC_AMIGA_PRINTSTATS
                else{
                        nullretries++;
                }
#endif
        }
 
        return ret;
}
 
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){
        atexit(&GC_amiga_free_all_mem);
        chipmax=(char *)SysBase->MaxLocMem;             // For people still having SysBase in chip-mem, this might speed up a bit.
        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
        return GC_amiga_allocwrapper_fast(size,AllocFunction);
}
 
 
#endif //GC_AMIGA_FASTALLOC
 
 
 
/*
 * The wrapped realloc function.
 *
 */
void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){
#ifndef GC_AMIGA_FASTALLOC
        return GC_realloc(old_object,new_size_in_bytes);
#else
        void *ret;
        latestsize=new_size_in_bytes;
        ret=GC_realloc(old_object,new_size_in_bytes);
        if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){
                /* Out of fast-mem. */
#ifdef GC_AMIGA_GC
                if(!GC_dont_gc){
                        GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
                        numcollects++;
#endif
                        ret=GC_realloc(old_object,new_size_in_bytes);
                }
#endif
                if(ret==NULL){
#ifndef GC_AMIGA_ONLYFAST
                        GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
                        if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
                        GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
                        ret=GC_realloc(old_object,new_size_in_bytes);
#endif
                }
#ifdef GC_AMIGA_PRINTSTATS
                else{
                        nullretries++;
                }
#endif
        }
        if(ret==NULL){
                WARN("Out of Memory!  Returning NIL!\n", 0);
        }
#ifdef GC_AMIGA_PRINTSTATS
        if(((char *)ret)<chipmax && ret!=NULL){
                chipa+=new_size_in_bytes;
        }
#endif
        return ret;
#endif
}
 
#endif //GC_AMIGA_AM
 
 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [boehm-gc/] [AmigaOS.c] - Blame information for rev 746

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