1 // General object definitions: pointers, reference counting, garbage collection.
7 #include "cln/modules.h"
12 // We don't have to deal with circular structures, so normal reference counting
13 // is sufficient. Is also has the advantage of being mostly non-interrupting.
16 // An object is either a pointer to heap allocated data
19 // It is possible to distinguish these because pointers are aligned.
20 // cl_word_alignment is the guaranteed alignment of a `void*' or `long'
21 // in memory. Must be > 1.
23 #define cl_word_alignment 2
25 #if defined(__i386__) || (defined(__mips__) && !defined(__LP64__)) || (defined(__sparc__) && !defined(__arch64__)) || defined(__hppa__) || defined(__arm__) || defined(__rs6000__) || defined(__m88k__) || defined(__convex__) || (defined(__s390__) && !defined(__s390x__)) || defined(__sh__) || (defined(__x86_64__) && defined(__ILP32__))
26 #define cl_word_alignment 4
28 #if defined(__alpha__) || defined(__ia64__) || defined(__mips64__) || defined(__powerpc64__) || (defined(__sparc__) && defined(__arch64__)) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(__s390x__) || defined(__aarch64__) || (defined(__riscv) && __riscv_xlen == 64) || defined(__e2k__)
29 #define cl_word_alignment 8
31 #if !defined(cl_word_alignment)
32 #error "Define cl_word_alignment for your CPU!"
36 // Four basic classes are introduced:
40 // gcpointer rcpointer
42 // `gcobject' = garbage collectible object (pointer or immediate),
43 // `gcpointer' = garbage collectible pointer,
44 // `rcobject' = reference counted object (pointer or immediate),
45 // `rcpointer' = reference counted pointer.
47 // "garbage collectible" means that a reference count is maintained, and
48 // when the reference count drops to 0, the object is freed. This is useful
49 // for all kind of short- or long-lived objects.
50 // "reference counted" means that a reference count is maintained, which
51 // cannot drop to 0. This is useful for objects which are registered in a
52 // global cache table, in order to know which objects can be thrown away
53 // when the cache is cleaned. (If the cache were never cleaned, its objects
54 // would never be freed, and we could get away with normal C pointers.)
56 // It is permissible to treat a `rcobject' as a `gcobject', and a `rcpointer'
57 // as a `gcpointer', but this just increases the destructor and copy-constructor
59 // It is also permissible to treat a `gcpointer' as a `gcobject', and a
60 // `rcpointer' as a `rcobject', but this just increases the destructor and
61 // copy-constructor overhead.
64 // Immediate data is a word, as wide as a pointer.
65 typedef sintP cl_sint;
66 typedef uintP cl_uint; // This ought to be called `cl_word'.
67 #define cl_pointer_size intPsize
68 // NB: (cl_pointer_size==64) implies defined(HAVE_FAST_LONGLONG)
69 #if (cl_pointer_size==64)
70 #define CL_WIDE_POINTERS
73 // Distinguish immediate data from pointers.
74 inline bool cl_pointer_p (cl_uint word)
76 return (word & (cl_word_alignment-1)) == 0;
78 inline bool cl_immediate_p (cl_uint word)
80 return (word & (cl_word_alignment-1)) != 0;
83 // Immediate data: Fixnum, Short Float, maybe Single Float.
84 // They have type tags.
85 // |...............................|......|
88 // Number of bits reserved for tagging information:
89 #if (cl_word_alignment <= 4)
94 #define cl_tag_shift 0
95 #define cl_value_shift (cl_tag_len+cl_tag_shift)
96 #define cl_value_len (cl_pointer_size - cl_value_shift)
97 #define cl_tag_mask ((((cl_uint)1 << cl_tag_len) - 1) << cl_tag_shift)
98 #define cl_value_mask ((((cl_uint)1 << cl_value_len) - 1) << cl_value_shift)
100 // Return the tag of a word.
101 inline cl_uint cl_tag (cl_uint word)
103 return (word & cl_tag_mask) >> cl_tag_shift;
106 // Return the value (unsigned) of a word.
107 inline cl_uint cl_value (cl_uint word)
109 // This assumes cl_value_shift + cl_value_len == cl_pointer_size.
110 return word >> cl_value_shift;
113 // Return a word, combining a value and a tag.
114 inline cl_uint cl_combine_impl (cl_uint tag, cl_uint value)
116 return (value << cl_value_shift) + (tag << cl_tag_shift);
118 inline cl_uint cl_combine_impl (cl_uint tag, cl_sint value)
120 // This assumes cl_value_shift + cl_value_len == cl_pointer_size.
121 return (value << cl_value_shift) + (tag << cl_tag_shift);
123 inline cl_uint cl_combine (cl_uint tag, unsigned int value)
124 { return cl_combine_impl(tag, (cl_uint)value); }
125 inline cl_uint cl_combine (cl_uint tag, int value)
126 { return cl_combine_impl(tag, (cl_sint)value); }
127 inline cl_uint cl_combine (cl_uint tag, unsigned long value)
128 { return cl_combine_impl(tag, (cl_uint)value); }
129 inline cl_uint cl_combine (cl_uint tag, long value)
130 { return cl_combine_impl(tag, (cl_sint)value); }
131 inline cl_uint cl_combine (cl_uint tag, unsigned long long value)
132 { return cl_combine_impl(tag, (cl_uint)value); }
133 inline cl_uint cl_combine (cl_uint tag, long long value)
134 { return cl_combine_impl(tag, (cl_uint)value); }
136 // Definition of the tags.
137 #if !defined(CL_WIDE_POINTERS)
138 #if (cl_word_alignment == 2)
140 #define cl_SF_tag 3 // must satisfy the cl_immediate_p predicate!
142 #if (cl_word_alignment == 4)
146 #else // CL_WIDE_POINTERS
147 // Single Floats are immediate as well.
153 // Corresponding classes.
154 extern const struct cl_class * cl_immediate_classes [1<<cl_tag_len];
157 // Heap allocated data contains a header, for two purposes:
159 // - reference count (a portable alternative to garbage collection,
160 // or the basis for a portable and interoperable garbage collection).
162 int refcount; // reference count
163 const struct cl_class * type; // type tag
166 // Function to destroy the contents of a heap object.
167 typedef void (*cl_heap_destructor_function) (cl_heap* pointer);
168 // Flags, may be ORed together.
169 #define cl_class_flags_subclass_complex 1 // all instances belong to cl_N
170 #define cl_class_flags_subclass_real 2 // all instances belong to cl_R
171 #define cl_class_flags_subclass_float 4 // all instances belong to cl_F
172 #define cl_class_flags_subclass_rational 8 // all instances belong to cl_RA
173 #define cl_class_flags_number_ring 16 // all instances are rings whose
174 // elements belong to cl_number
175 #define cl_class_flags_modint_ring 32 // all instances are rings whose
176 // elements belong to cl_MI
177 #define cl_class_flags_univpoly_ring 64 // all instances are rings whose
178 // elements belong to cl_UP
179 // Function to print an object for debugging, to cerr.
180 typedef void (*cl_heap_dprint_function) (cl_heap* pointer);
183 cl_heap_destructor_function destruct;
185 cl_heap_dprint_function dprint;
188 // Free an object on heap.
189 extern void cl_free_heap_object (cl_heap* pointer);
191 // Debugging support for dynamic typing: Register a debugging print function.
192 #define cl_register_type_printer(type,printer) \
193 { extern cl_class type; type.dprint = (printer); }
196 // cl_private_thing: An immediate value or a pointer into the heap.
197 // This must be as wide as a `cl_uint'.
198 // (Actually, this ought to be a union { void*; cl_uint; }, but using
199 // a pointer type generates better code.)
200 // Never throw away a cl_private_thing, or reference counts will be wrong!
201 typedef struct cl_anything * cl_private_thing;
203 // Increment the reference count.
204 inline void cl_inc_pointer_refcount (cl_heap* pointer)
209 // Decrement the reference count of a garbage collected pointer.
210 inline void cl_gc_dec_pointer_refcount (cl_heap* pointer)
212 if (--pointer->refcount == 0)
213 cl_free_heap_object(pointer);
215 // Decrement the reference count of a reference counted pointer.
216 inline void cl_rc_dec_pointer_refcount (cl_heap* pointer)
221 // Increment the reference count.
222 // This must be a macro, not an inline function, because pointer_p() and
223 // inc_pointer_refcount() are non-virtual member functions, so that the
224 // compiler can optimize it.
225 #define cl_inc_refcount(x) \
226 if ((x).pointer_p()) \
227 (x).inc_pointer_refcount(); \
229 // Decrement the reference count.
230 // This must be a macro, not an inline function, because pointer_p() and
231 // dec_pointer_refcount() are non-virtual member functions, so that the
232 // compiler can optimize it.
233 #define cl_dec_refcount(x) \
234 if ((x).pointer_p()) \
235 (x).dec_pointer_refcount(); \
237 // The declaration of a copy constructor.
238 // Restriction: The base class's default constructor must do nothing or
239 // initialize `pointer' to a constant expression.
240 #define CL_DEFINE_COPY_CONSTRUCTOR1(_class_) \
241 _CL_DEFINE_COPY_CONSTRUCTOR1(_class_,_class_)
242 #define _CL_DEFINE_COPY_CONSTRUCTOR1(_class_,_classname_) \
243 inline _class_::_classname_ (const _class_& x) \
245 cl_uint x_word = x.word; \
246 cl_inc_refcount(x); \
247 this->word = x_word; \
250 // The declaration of a copy constructor.
251 // Restriction: The base class must have the usual `cl_private_thing'
252 // constructor. Drawback: The base class must be known here.
253 #define CL_DEFINE_COPY_CONSTRUCTOR2(_class_,_baseclass_) \
254 _CL_DEFINE_COPY_CONSTRUCTOR2(_class_,_class_,_baseclass_)
255 #define _CL_DEFINE_COPY_CONSTRUCTOR2(_class_,_classname_,_baseclass_) \
256 inline _class_::_classname_ (const _class_& x) \
257 : _baseclass_ (as_cl_private_thing(x)) {}
259 // The declaration of an assignment operator.
260 #define CL_DEFINE_ASSIGNMENT_OPERATOR(dest_class,src_class) \
261 inline dest_class& dest_class::operator= (const src_class& x) \
263 /* Be careful, we might be assigning x to itself. */ \
264 cl_uint x_word = x.word; \
265 cl_inc_refcount(x); \
266 cl_dec_refcount(*this); \
267 this->word = x_word; \
271 // We have a small problem with destructors: The specialized destructor
272 // of a leaf class such as `cl_SF' should be more efficient than the
273 // general destructor for `cl_N'. Since (by C++ specs) destructing a cl_SF
274 // would run the destructors for cl_SF, cl_F, cl_R, cl_N (in that order),
275 // and in the last step the compiler does not know any more that the object
276 // actually is a cl_SF, there is no way to optimize the destructor!
277 // ("progn-reversed" method combination is evil.)
278 // And if we define "mirror"/"shadow" classes with no destructors (such
279 // that `cl_F' inherits from `cl_F_no_destructor' buts adds a destructor)
280 // then we need to add explicit conversion operators cl_SF -> cl_F -> cl_R ...,
281 // with the effect that calling an overloaded function like `as_cl_F'
282 // (which has two signatures `as_cl_F(cl_number)' and `as_cl_F(cl_F)')
283 // with a cl_SF argument gives an "call of overloaded function is ambiguous"
285 // There is no help: If we want overloaded functions to be callable in a way
286 // that makes sense, `cl_SF' has to be a subclass of `cl_F', and then the
287 // destructor of `cl_SF' will do at least as much computation as the `cl_F'
288 // destructor. Praise C++ ! :-((
289 // (Even making `pointer_p()' a virtual function would not help.)
292 // This is obnoxious.
293 template <class key1_type, class value_type> struct cl_htentry1;
295 // The four concrete classes of all objects.
301 cl_heap* heappointer;
305 // Default constructor. (Used for objects with no initializer.)
307 // Destructor. (Used when a variable goes out of scope.)
310 cl_gcobject (const cl_gcobject&);
311 // Assignment operator.
312 cl_gcobject& operator= (const cl_gcobject&);
313 // Distinguish immediate data from pointer.
314 bool pointer_p() const
315 { return cl_pointer_p(word); }
316 // Reference counting.
317 void inc_pointer_refcount () const
318 { cl_inc_pointer_refcount(heappointer); }
319 void dec_pointer_refcount () const
320 { cl_gc_dec_pointer_refcount(heappointer); }
321 // Return the type tag of an immediate number.
322 cl_uint nonpointer_tag () const
323 { return cl_tag(word); }
324 // Return the type tag of a heap-allocated number.
325 const cl_class * pointer_type () const
326 { return heappointer->type; }
327 // Private pointer manipulations.
328 cl_private_thing _as_cl_private_thing () const;
329 // Private constructor.
330 cl_gcobject (cl_private_thing p)
333 void debug_print () const;
334 // Ability to place an object at a given address.
335 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
336 void* operator new (size_t size) { return ::operator new (size); }
338 inline cl_gcobject::cl_gcobject () {}
339 inline cl_gcobject::~cl_gcobject () { cl_dec_refcount(*this); }
340 CL_DEFINE_COPY_CONSTRUCTOR1(cl_gcobject)
341 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_gcobject,cl_gcobject)
347 cl_heap* heappointer;
351 // Default constructor. (Used for objects with no initializer.)
353 // Destructor. (Used when a variable goes out of scope.)
356 cl_gcpointer (const cl_gcpointer&);
357 // Assignment operator.
358 cl_gcpointer& operator= (const cl_gcpointer&);
359 // Distinguish immediate data from pointer.
360 bool pointer_p() const
362 // Reference counting.
363 void inc_pointer_refcount () const
364 { cl_inc_pointer_refcount(heappointer); }
365 void dec_pointer_refcount () const
366 { cl_gc_dec_pointer_refcount(heappointer); }
367 // Return the type tag of an immediate number.
368 cl_uint nonpointer_tag () const
369 { return cl_tag(word); }
370 // Return the type tag of a heap-allocated number.
371 const cl_class * pointer_type () const
372 { return heappointer->type; }
373 // Private pointer manipulations.
374 cl_private_thing _as_cl_private_thing () const;
375 // Private constructor.
376 cl_gcpointer (cl_private_thing p)
379 void debug_print () const;
380 // Ability to place an object at a given address.
381 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
382 void* operator new (size_t size) { return ::operator new (size); }
384 inline cl_gcpointer::cl_gcpointer () {}
385 inline cl_gcpointer::~cl_gcpointer () { cl_dec_refcount(*this); }
386 CL_DEFINE_COPY_CONSTRUCTOR1(cl_gcpointer)
387 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_gcpointer,cl_gcpointer)
393 cl_heap* heappointer;
397 // Default constructor. (Used for objects with no initializer.)
399 // Destructor. (Used when a variable goes out of scope.)
402 cl_rcobject (const cl_rcobject&);
403 // Assignment operator.
404 cl_rcobject& operator= (const cl_rcobject&);
405 // Distinguish immediate data from pointer.
406 bool pointer_p() const
407 { return cl_pointer_p(word); }
408 // Reference counting.
409 void inc_pointer_refcount () const
410 { cl_inc_pointer_refcount(heappointer); }
411 void dec_pointer_refcount () const
412 { cl_rc_dec_pointer_refcount(heappointer); }
413 // Return the type tag of an immediate number.
414 cl_uint nonpointer_tag () const
415 { return cl_tag(word); }
416 // Return the type tag of a heap-allocated number.
417 const cl_class * pointer_type () const
418 { return heappointer->type; }
419 // Private pointer manipulations.
420 cl_private_thing _as_cl_private_thing () const;
421 // Private constructor.
422 cl_rcobject (cl_private_thing p)
425 void debug_print () const;
426 // Ability to place an object at a given address.
427 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
428 void* operator new (size_t size) { return ::operator new (size); }
430 inline cl_rcobject::cl_rcobject () {}
431 inline cl_rcobject::~cl_rcobject () { cl_dec_refcount(*this); }
432 CL_DEFINE_COPY_CONSTRUCTOR1(cl_rcobject)
433 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_rcobject,cl_rcobject)
439 cl_heap* heappointer;
443 // Default constructor. (Used for objects with no initializer.)
445 // Destructor. (Used when a variable goes out of scope.)
448 cl_rcpointer (const cl_rcpointer&);
449 // Assignment operator.
450 cl_rcpointer& operator= (const cl_rcpointer&);
451 // Distinguish immediate data from pointer.
452 bool pointer_p() const
454 // Reference counting.
455 void inc_pointer_refcount () const
456 { cl_inc_pointer_refcount(heappointer); }
457 void dec_pointer_refcount () const
458 { cl_rc_dec_pointer_refcount(heappointer); }
459 // Return the type tag of an immediate number.
460 cl_uint nonpointer_tag () const
461 { return cl_tag(word); }
462 // Return the type tag of a heap-allocated number.
463 const cl_class * pointer_type () const
464 { return heappointer->type; }
465 // Private pointer manipulations.
466 cl_private_thing _as_cl_private_thing () const;
467 // Private constructor.
468 cl_rcpointer (cl_private_thing p)
471 void debug_print () const;
472 // Ability to place an object at a given address.
473 void* operator new (size_t size, void* ptr) { (void)size; return ptr; }
474 void* operator new (size_t size) { return ::operator new (size); }
476 inline cl_rcpointer::cl_rcpointer () {}
477 inline cl_rcpointer::~cl_rcpointer () { cl_dec_refcount(*this); }
478 CL_DEFINE_COPY_CONSTRUCTOR1(cl_rcpointer)
479 CL_DEFINE_ASSIGNMENT_OPERATOR(cl_rcpointer,cl_rcpointer)
481 // Private pointer manipulations.
483 inline cl_private_thing cl_gcobject::_as_cl_private_thing () const
485 cl_private_thing p = (cl_private_thing) pointer;
486 cl_inc_refcount(*this);
489 inline cl_private_thing as_cl_private_thing (const cl_gcobject& x)
491 return x._as_cl_private_thing();
494 inline cl_private_thing cl_gcpointer::_as_cl_private_thing () const
496 cl_private_thing p = (cl_private_thing) pointer;
497 cl_inc_refcount(*this);
500 inline cl_private_thing as_cl_private_thing (const cl_gcpointer& x)
502 return x._as_cl_private_thing();
505 inline cl_private_thing cl_rcobject::_as_cl_private_thing () const
507 cl_private_thing p = (cl_private_thing) pointer;
508 cl_inc_refcount(*this);
511 inline cl_private_thing as_cl_private_thing (const cl_rcobject& x)
513 return x._as_cl_private_thing();
516 inline cl_private_thing cl_rcpointer::_as_cl_private_thing () const
518 cl_private_thing p = (cl_private_thing) pointer;
519 cl_inc_refcount(*this);
522 inline cl_private_thing as_cl_private_thing (const cl_rcpointer& x)
524 return x._as_cl_private_thing();
527 // Note: When we define a function that returns a class object by value,
528 // we normally return it as const value. The declarations
531 // const T func (...); (B)
532 // behave identically and generate identical code, except that the code
534 // compiles fine with (A) but is an error (and yields a warning) with (B).
535 // We want this warning.
537 // Define a conversion operator from one object to another object of the
539 #define CL_DEFINE_CONVERTER(target_class) \
540 operator const target_class & () const \
542 int (*dummy1)(int assert1 [2*(sizeof(target_class)==sizeof(*this))-1]); (void)dummy1; \
543 return * (const target_class *) (void*) this; \
548 #endif /* _CL_OBJECT_H */