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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [boehm-gc/] [include/] [gc_allocator.h] - Blame information for rev 721

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 721 jeremybenn
/*
2
 * Copyright (c) 1996-1997
3
 * Silicon Graphics Computer Systems, Inc.
4
 *
5
 * Permission to use, copy, modify, distribute and sell this software
6
 * and its documentation for any purpose is hereby granted without fee,
7
 * provided that the above copyright notice appear in all copies and
8
 * that both that copyright notice and this permission notice appear
9
 * in supporting documentation.  Silicon Graphics makes no
10
 * representations about the suitability of this software for any
11
 * purpose.  It is provided "as is" without express or implied warranty.
12
 *
13
 * Copyright (c) 2002
14
 * Hewlett-Packard Company
15
 *
16
 * Permission to use, copy, modify, distribute and sell this software
17
 * and its documentation for any purpose is hereby granted without fee,
18
 * provided that the above copyright notice appear in all copies and
19
 * that both that copyright notice and this permission notice appear
20
 * in supporting documentation.  Hewlett-Packard Company makes no
21
 * representations about the suitability of this software for any
22
 * purpose.  It is provided "as is" without express or implied warranty.
23
 */
24
 
25
/*
26
 * This implements standard-conforming allocators that interact with
27
 * the garbage collector.  Gc_alloctor<T> allocates garbage-collectable
28
 * objects of type T.  Traceable_allocator<T> allocates objects that
29
 * are not temselves garbage collected, but are scanned by the
30
 * collector for pointers to collectable objects.  Traceable_alloc
31
 * should be used for explicitly managed STL containers that may
32
 * point to collectable objects.
33
 *
34
 * This code was derived from an earlier version of the GNU C++ standard
35
 * library, which itself was derived from the SGI STL implementation.
36
 */
37
 
38
#ifndef GC_ALLOCATOR_H
39
 
40
#define GC_ALLOCATOR_H
41
 
42
#include "gc.h"
43
 
44
#if defined(__GNUC__)
45
#  define GC_ATTR_UNUSED __attribute__((unused))
46
#else
47
#  define GC_ATTR_UNUSED
48
#endif
49
 
50
/* First some helpers to allow us to dispatch on whether or not a type
51
 * is known to be pointerfree.
52
 * These are private, except that the client may invoke the
53
 * GC_DECLARE_PTRFREE macro.
54
 */
55
 
56
struct GC_true_type {};
57
struct GC_false_type {};
58
 
59
template <class GC_tp>
60
struct GC_type_traits {
61
  GC_false_type GC_is_ptr_free;
62
};
63
 
64
# define GC_DECLARE_PTRFREE(T) \
65
template<> struct GC_type_traits<T> { GC_true_type GC_is_ptr_free; }
66
 
67
GC_DECLARE_PTRFREE(signed char);
68
GC_DECLARE_PTRFREE(unsigned char);
69
GC_DECLARE_PTRFREE(signed short);
70
GC_DECLARE_PTRFREE(unsigned short);
71
GC_DECLARE_PTRFREE(signed int);
72
GC_DECLARE_PTRFREE(unsigned int);
73
GC_DECLARE_PTRFREE(signed long);
74
GC_DECLARE_PTRFREE(unsigned long);
75
GC_DECLARE_PTRFREE(float);
76
GC_DECLARE_PTRFREE(double);
77
/* The client may want to add others.   */
78
 
79
// In the following GC_Tp is GC_true_type iff we are allocating a
80
// pointerfree object.
81
template <class GC_Tp>
82
inline void * GC_selective_alloc(size_t n, GC_Tp) {
83
    return GC_MALLOC(n);
84
}
85
 
86
template <>
87
inline void * GC_selective_alloc<GC_true_type>(size_t n, GC_true_type) {
88
    return GC_MALLOC_ATOMIC(n);
89
}
90
 
91
/* Now the public gc_allocator<T> class:
92
 */
93
template <class GC_Tp>
94
class gc_allocator {
95
public:
96
  typedef size_t     size_type;
97
  typedef ptrdiff_t  difference_type;
98
  typedef GC_Tp*       pointer;
99
  typedef const GC_Tp* const_pointer;
100
  typedef GC_Tp&       reference;
101
  typedef const GC_Tp& const_reference;
102
  typedef GC_Tp        value_type;
103
 
104
  template <class GC_Tp1> struct rebind {
105
    typedef gc_allocator<GC_Tp1> other;
106
  };
107
 
108
  gc_allocator()  {}
109
# ifndef _MSC_VER
110
    // I'm not sure why this is needed here in addition to the following.
111
    // The standard specifies it for the standard allocator, but VC++ rejects
112
    // it.      -HB
113
    gc_allocator(const gc_allocator&) throw() {}
114
# endif
115
  template <class GC_Tp1> gc_allocator(const gc_allocator<GC_Tp1>&) throw() {}
116
  ~gc_allocator() throw() {}
117
 
118
  pointer address(reference GC_x) const { return &GC_x; }
119
  const_pointer address(const_reference GC_x) const { return &GC_x; }
120
 
121
  // GC_n is permitted to be 0.  The C++ standard says nothing about what
122
  // the return value is when GC_n == 0.
123
  GC_Tp* allocate(size_type GC_n, const void* = 0) {
124
    GC_type_traits<GC_Tp> traits;
125
    return static_cast<GC_Tp *>
126
            (GC_selective_alloc(GC_n * sizeof(GC_Tp),
127
                                traits.GC_is_ptr_free));
128
  }
129
 
130
  // __p is not permitted to be a null pointer.
131
  void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n)
132
    { GC_FREE(__p); }
133
 
134
  size_type max_size() const throw()
135
    { return size_t(-1) / sizeof(GC_Tp); }
136
 
137
  void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
138
  void destroy(pointer __p) { __p->~GC_Tp(); }
139
};
140
 
141
template<>
142
class gc_allocator<void> {
143
  typedef size_t      size_type;
144
  typedef ptrdiff_t   difference_type;
145
  typedef void*       pointer;
146
  typedef const void* const_pointer;
147
  typedef void        value_type;
148
 
149
  template <class GC_Tp1> struct rebind {
150
    typedef gc_allocator<GC_Tp1> other;
151
  };
152
};
153
 
154
 
155
template <class GC_T1, class GC_T2>
156
inline bool operator==(const gc_allocator<GC_T1>&, const gc_allocator<GC_T2>&)
157
{
158
  return true;
159
}
160
 
161
template <class GC_T1, class GC_T2>
162
inline bool operator!=(const gc_allocator<GC_T1>&, const gc_allocator<GC_T2>&)
163
{
164
  return false;
165
}
166
 
167
/*
168
 * And the public traceable_allocator class.
169
 */
170
 
171
// Note that we currently don't specialize the pointer-free case, since a
172
// pointer-free traceable container doesn't make that much sense,
173
// though it could become an issue due to abstraction boundaries.
174
template <class GC_Tp>
175
class traceable_allocator {
176
public:
177
  typedef size_t     size_type;
178
  typedef ptrdiff_t  difference_type;
179
  typedef GC_Tp*       pointer;
180
  typedef const GC_Tp* const_pointer;
181
  typedef GC_Tp&       reference;
182
  typedef const GC_Tp& const_reference;
183
  typedef GC_Tp        value_type;
184
 
185
  template <class GC_Tp1> struct rebind {
186
    typedef traceable_allocator<GC_Tp1> other;
187
  };
188
 
189
  traceable_allocator() throw() {}
190
# ifndef _MSC_VER
191
    traceable_allocator(const traceable_allocator&) throw() {}
192
# endif
193
  template <class GC_Tp1> traceable_allocator
194
          (const traceable_allocator<GC_Tp1>&) throw() {}
195
  ~traceable_allocator() throw() {}
196
 
197
  pointer address(reference GC_x) const { return &GC_x; }
198
  const_pointer address(const_reference GC_x) const { return &GC_x; }
199
 
200
  // GC_n is permitted to be 0.  The C++ standard says nothing about what
201
  // the return value is when GC_n == 0.
202
  GC_Tp* allocate(size_type GC_n, const void* = 0) {
203
    return static_cast<GC_Tp*>(GC_MALLOC_UNCOLLECTABLE(GC_n * sizeof(GC_Tp)));
204
  }
205
 
206
  // __p is not permitted to be a null pointer.
207
  void deallocate(pointer __p, size_type GC_ATTR_UNUSED GC_n)
208
    { GC_FREE(__p); }
209
 
210
  size_type max_size() const throw()
211
    { return size_t(-1) / sizeof(GC_Tp); }
212
 
213
  void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
214
  void destroy(pointer __p) { __p->~GC_Tp(); }
215
};
216
 
217
template<>
218
class traceable_allocator<void> {
219
  typedef size_t      size_type;
220
  typedef ptrdiff_t   difference_type;
221
  typedef void*       pointer;
222
  typedef const void* const_pointer;
223
  typedef void        value_type;
224
 
225
  template <class GC_Tp1> struct rebind {
226
    typedef traceable_allocator<GC_Tp1> other;
227
  };
228
};
229
 
230
 
231
template <class GC_T1, class GC_T2>
232
inline bool operator==(const traceable_allocator<GC_T1>&, const traceable_allocator<GC_T2>&)
233
{
234
  return true;
235
}
236
 
237
template <class GC_T1, class GC_T2>
238
inline bool operator!=(const traceable_allocator<GC_T1>&, const traceable_allocator<GC_T2>&)
239
{
240
  return false;
241
}
242
 
243
#endif /* GC_ALLOCATOR_H */

powered by: WebSVN 2.1.0

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