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

Subversion Repositories openrisc

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

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

Line No. Rev Author Line
1 721 jeremybenn
/*
2
 * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
3
 *
4
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
5
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
6
 *
7
 * Permission is hereby granted to use or copy this program
8
 * for any purpose,  provided the above notices are retained on all copies.
9
 * Permission to modify the code and to distribute modified code is granted,
10
 * provided the above notices are retained, and a notice that the code was
11
 * modified is included with the above copyright notice.
12
 */
13
# include "private/gc_priv.h"
14
 
15
# ifdef PCR
16
/*
17
 * Note that POSIX PCR requires an ANSI C compiler.  Hence we are allowed
18
 * to make the same assumption here.
19
 * We wrap all of the allocator functions to avoid questions of
20
 * compatibility between the prototyped and nonprototyped versions of the f
21
 */
22
# include "config/PCR_StdTypes.h"
23
# include "mm/PCR_MM.h"
24
# include <errno.h>
25
 
26
# define MY_MAGIC 17L
27
# define MY_DEBUGMAGIC 42L
28
 
29
void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
30
{
31
    if (ptrFree) {
32
        void * result = (void *)GC_malloc_atomic(size);
33
        if (clear && result != 0) BZERO(result, size);
34
        return(result);
35
    } else {
36
        return((void *)GC_malloc(size));
37
    }
38
}
39
 
40
void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
41
{
42
    if (ptrFree) {
43
        void * result = (void *)GC_debug_malloc_atomic(size, __FILE__,
44
                                                             __LINE__);
45
        if (clear && result != 0) BZERO(result, size);
46
        return(result);
47
    } else {
48
        return((void *)GC_debug_malloc(size, __FILE__, __LINE__));
49
    }
50
}
51
 
52
# define GC_ReallocProc GC_realloc
53
void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes)
54
{
55
    return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__));
56
}
57
 
58
# define GC_FreeProc GC_free
59
# define GC_DebugFreeProc GC_debug_free
60
 
61
typedef struct {
62
  PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
63
  GC_bool ed_pointerfree;
64
  PCR_ERes ed_fail_code;
65
  PCR_Any ed_client_data;
66
} enumerate_data;
67
 
68
void GC_enumerate_block(h, ed)
69
register struct hblk *h;
70
enumerate_data * ed;
71
{
72
    register hdr * hhdr;
73
    register int sz;
74
    word *p;
75
    word * lim;
76
 
77
    hhdr = HDR(h);
78
    sz = hhdr -> hb_sz;
79
    if (sz >= 0 && ed -> ed_pointerfree
80
        || sz <= 0 && !(ed -> ed_pointerfree)) return;
81
    if (sz < 0) sz = -sz;
82
    lim = (word *)(h+1) - sz;
83
    p = (word *)h;
84
    do {
85
        if (PCR_ERes_IsErr(ed -> ed_fail_code)) return;
86
        ed -> ed_fail_code =
87
            (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data);
88
        p+= sz;
89
    } while (p <= lim);
90
}
91
 
92
struct PCR_MM_ProcsRep * GC_old_allocator = 0;
93
 
94
PCR_ERes GC_EnumerateProc(
95
    PCR_Bool ptrFree,
96
    PCR_ERes (*proc)(void *p, size_t size, PCR_Any data),
97
    PCR_Any data
98
)
99
{
100
    enumerate_data ed;
101
 
102
    ed.ed_proc = proc;
103
    ed.ed_pointerfree = ptrFree;
104
    ed.ed_fail_code = PCR_ERes_okay;
105
    ed.ed_client_data = data;
106
    GC_apply_to_all_blocks(GC_enumerate_block, &ed);
107
    if (ed.ed_fail_code != PCR_ERes_okay) {
108
        return(ed.ed_fail_code);
109
    } else {
110
        /* Also enumerate objects allocated by my predecessors */
111
        return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data));
112
    }
113
}
114
 
115
void GC_DummyFreeProc(void *p) {}
116
 
117
void GC_DummyShutdownProc(void) {}
118
 
119
struct PCR_MM_ProcsRep GC_Rep = {
120
        MY_MAGIC,
121
        GC_AllocProc,
122
        GC_ReallocProc,
123
        GC_DummyFreeProc,       /* mmp_free */
124
        GC_FreeProc,            /* mmp_unsafeFree */
125
        GC_EnumerateProc,
126
        GC_DummyShutdownProc    /* mmp_shutdown */
127
};
128
 
129
struct PCR_MM_ProcsRep GC_DebugRep = {
130
        MY_DEBUGMAGIC,
131
        GC_DebugAllocProc,
132
        GC_DebugReallocProc,
133
        GC_DummyFreeProc,       /* mmp_free */
134
        GC_DebugFreeProc,               /* mmp_unsafeFree */
135
        GC_EnumerateProc,
136
        GC_DummyShutdownProc    /* mmp_shutdown */
137
};
138
 
139
GC_bool GC_use_debug = 0;
140
 
141
void GC_pcr_install()
142
{
143
    PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator);
144
}
145
 
146
PCR_ERes
147
PCR_GC_Setup(void)
148
{
149
    return PCR_ERes_okay;
150
}
151
 
152
PCR_ERes
153
PCR_GC_Run(void)
154
{
155
 
156
    if( !PCR_Base_TestPCRArg("-nogc") ) {
157
        GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
158
        GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc");
159
        GC_init();
160
        if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
161
            /*
162
             * awful hack to test whether VD is implemented ...
163
             */
164
            if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
165
                GC_enable_incremental();
166
            }
167
        }
168
    }
169
    return PCR_ERes_okay;
170
}
171
 
172
void GC_push_thread_structures(void)
173
{
174
    /* PCR doesn't work unless static roots are pushed.  Can't get here. */
175
    ABORT("In GC_push_thread_structures()");
176
}
177
 
178
# endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.