source: branches/arm/lisp-kernel/gc.h @ 13923

Last change on this file since 13923 was 13737, checked in by gb, 9 years ago

Get the kernel to compile/link/run on ARM Linux; remove some PPC-isms and
add some ARM-isms, though there's likely more of the latter to be done
to support exceptions/GC.

Raise subprim addresses to start at #x9000, since some distributions
set vm.mmap_min_addr to #x8000 and others act as if they do. This means
that some subprims (whose addresses are above #x10000) will be spaced 1K
apart; maybe not so bad for keyword handling/FFI/some other things.

Re-partition UUOs, so that those that require direct action from a kernel
handler are easier to distinguish from lisp-level errors.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.4 KB
Line 
1/*
2   Copyright (C) 2009 Clozure Associates
3   Copyright (C) 1994-2001 Digitool, Inc
4   This file is part of Clozure CL. 
5
6   Clozure CL is licensed under the terms of the Lisp Lesser GNU Public
7   License , known as the LLGPL and distributed with Clozure CL as the
8   file "LICENSE".  The LLGPL consists of a preamble and the LGPL,
9   which is distributed with Clozure CL as the file "LGPL".  Where these
10   conflict, the preamble takes precedence. 
11
12   Clozure CL is referenced in the preamble as the "LIBRARY."
13
14   The LLGPL is also available online at
15   http://opensource.franz.com/preamble.html
16*/
17
18#ifndef __GC_H__
19#define __GC_H__ 1
20
21#include "lisp.h"
22#include "bits.h"
23#include "lisp-exceptions.h"
24#include "memprotect.h"
25
26
27
28#ifdef PPC
29#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)|(1<<fulltag_misc)))
30#ifdef PPC64
31#define PPC64_CODE_VECTOR_PREFIX (('C'<< 24) | ('O' << 16) | ('D' << 8) | 'E')
32#else
33/*
34  A code-vector's header can't look like a valid instruction or UUO:
35  the low 8 bits must be subtag_code_vector, and the top 6 bits
36  must be 0.  That means that the maximum length of a code vector
37  is 18 bits worth of elements (~1MB.)
38*/
39
40#define code_header_mask ((0x3f<<26) | subtag_code_vector)
41#endif
42#endif
43
44#ifdef X86
45#ifdef X8664
46#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)    | \
47                                       (1<<fulltag_tra_0)   | \
48                                       (1<<fulltag_tra_1)   | \
49                                       (1<<fulltag_misc)    | \
50                                       (1<<fulltag_symbol)  | \
51                                       (1<<fulltag_function)))
52#else
53#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons) | \
54                                       (1<<fulltag_misc) | \
55                                       (1<<fulltag_tra)))
56#endif
57#endif
58
59#ifdef ARM
60#define is_node_fulltag(f)  ((1<<(f))&((1<<fulltag_cons)|(1<<fulltag_misc)))
61#endif
62
63extern void zero_memory_range(BytePtr,BytePtr);
64extern LispObj GCarealow, GCareadynamiclow;
65extern natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
66extern bitvector GCmarkbits, GCdynamic_markbits;
67LispObj *global_reloctab, *GCrelocptr;
68LispObj GCfirstunmarked;
69
70extern natural lisp_heap_gc_threshold;
71void mark_root(LispObj);
72void mark_pc_root(LispObj);
73void mark_locative_root(LispObj);
74void rmark(LispObj);
75void postGCfree(void *);
76LispObj *skip_over_ivector(LispObj, LispObj);
77void mark_simple_area_range(LispObj *,LispObj *);
78LispObj calculate_relocation();
79LispObj locative_forwarding_address(LispObj);
80LispObj node_forwarding_address(LispObj);
81void forward_range(LispObj *, LispObj *);
82void note_memoized_references(ExceptionInformation *,LogicalAddress, LogicalAddress, BytePtr *, BytePtr *);
83void gc(TCR *, signed_natural);
84int change_hons_area_size(TCR *, signed_natural);
85void delete_protected_area(protected_area_ptr);
86Boolean egc_control(Boolean, BytePtr);
87Boolean free_segments_zero_filled_by_OS;
88
89/* an type representing 1/4 of a natural word */
90#if WORD_SIZE == 64
91typedef unsigned short qnode;
92#else
93typedef unsigned char qnode;
94#endif
95
96
97#ifdef fulltag_symbol
98#define is_symbol_fulltag(x) (fulltag_of(x) == fulltag_symbol)
99#else
100#define is_symbol_fulltag(x) (fulltag_of(x) == fulltag_misc)
101#endif
102
103#define area_dnode(w,low) ((natural)(((ptr_to_lispobj(w)) - ptr_to_lispobj(low))>>dnode_shift))
104#define gc_area_dnode(w)  area_dnode(w,GCarealow)
105#define gc_dynamic_area_dnode(w) area_dnode(w,GCareadynamiclow)
106
107#if defined(PPC64) || defined(X8632)
108#define forward_marker subtag_forward_marker
109#else
110#define forward_marker fulltag_nil
111#endif
112
113#ifdef PPC64
114#define VOID_ALLOCPTR ((LispObj)(0x8000000000000000-dnode_size))
115#else
116#define VOID_ALLOCPTR ((LispObj)(-dnode_size))
117#endif
118
119#ifdef DARWIN
120#include <mach/task_info.h>
121typedef struct task_events_info paging_info;
122#else
123#ifndef WINDOWS
124#include <sys/resource.h>
125typedef struct rusage paging_info;
126#else
127typedef natural paging_info;
128#endif
129#endif
130
131#undef __argv
132#include <stdio.h>
133
134void sample_paging_info(paging_info *);
135void report_paging_info_delta(FILE*, paging_info *, paging_info *);
136
137
138#define GC_TRAP_FUNCTION_IMMEDIATE_GC (-1)
139#define GC_TRAP_FUNCTION_GC 0
140#define GC_TRAP_FUNCTION_PURIFY 1
141#define GC_TRAP_FUNCTION_IMPURIFY 2
142#define GC_TRAP_FUNCTION_FLASH_FREEZE 4
143#define GC_TRAP_FUNCTION_SAVE_APPLICATION 8
144
145#define GC_TRAP_FUNCTION_GET_LISP_HEAP_THRESHOLD 16
146#define GC_TRAP_FUNCTION_SET_LISP_HEAP_THRESHOLD 17
147#define GC_TRAP_FUNCTION_USE_LISP_HEAP_THRESHOLD 18
148#define GC_TRAP_FUNCTION_ENSURE_STATIC_CONSES 19
149#define GC_TRAP_FUNCTION_EGC_CONTROL 32
150#define GC_TRAP_FUNCTION_CONFIGURE_EGC 64
151#define GC_TRAP_FUNCTION_FREEZE 129
152#define GC_TRAP_FUNCTION_THAW 130
153
154Boolean GCDebug, GCverbose, just_purified_p;
155bitvector GCmarkbits, GCdynamic_markbits;
156LispObj GCarealow, GCareadynamiclow;
157natural GCndnodes_in_area, GCndynamic_dnodes_in_area;
158LispObj GCweakvll,GCdwsweakvll;
159LispObj GCephemeral_low;
160natural GCn_ephemeral_dnodes;
161natural GCstack_limit;
162
163#if WORD_SIZE == 64
164unsigned short *_one_bits;
165#else
166const unsigned char _one_bits[256];
167#endif
168
169#define one_bits(x) _one_bits[x]
170
171natural static_dnodes_for_area(area *a);
172void reapweakv(LispObj weakv);
173void reaphashv(LispObj hashv);
174Boolean mark_weak_hash_vector(hash_table_vector_header *hashp, natural elements);
175Boolean mark_weak_alist(LispObj weak_alist, int weak_type);
176void mark_tcr_tlb(TCR *);
177void mark_tcr_xframes(TCR *);
178void freeGCptrs(void);
179void reap_gcable_ptrs(void);
180unsigned short logcount16(unsigned short);
181void gc_init(void);
182LispObj node_forwarding_address(LispObj);
183Boolean update_noderef(LispObj *);
184void update_locref(LispObj *);
185void forward_gcable_ptrs(void);
186void forward_memoized_area(area *, natural);
187void forward_tcr_tlb(TCR *);
188void reclaim_static_dnodes(void);
189Boolean youngest_non_null_area_p(area *);
190void gc(TCR *, signed_natural);
191
192/* backend-interface */
193
194typedef void (*weak_mark_fun) (LispObj);
195weak_mark_fun mark_weak_htabv, dws_mark_weak_htabv;
196
197typedef void (*weak_process_fun)(void);
198
199weak_process_fun markhtabvs;
200
201
202#define hash_table_vector_header_count (sizeof(hash_table_vector_header)/sizeof(LispObj))
203
204void mark_root(LispObj);
205void rmark(LispObj);
206#ifdef X8632
207void mark_xp(ExceptionInformation *, natural);
208#else
209void mark_xp(ExceptionInformation *);
210#endif
211LispObj dnode_forwarding_address(natural, int);
212LispObj locative_forwarding_address(LispObj);
213void check_refmap_consistency(LispObj *, LispObj *, bitvector);
214void check_all_areas(TCR *);
215void mark_tstack_area(area *);
216void mark_vstack_area(area *);
217void mark_cstack_area(area *);
218void mark_simple_area_range(LispObj *, LispObj *);
219void mark_memoized_area(area *, natural);
220LispObj calculate_relocation(void);
221void forward_range(LispObj *, LispObj *);
222void forward_tstack_area(area *);
223void forward_vstack_area(area *);
224void forward_cstack_area(area *);
225LispObj compact_dynamic_heap(void);
226signed_natural purify(TCR *, signed_natural);
227signed_natural impurify(TCR *, signed_natural);
228signed_natural gc_like_from_xp(ExceptionInformation *, signed_natural(*fun)(TCR *, signed_natural), signed_natural);
229
230
231typedef enum {
232  xmacptr_flag_none = 0,        /* Maybe already disposed by Lisp */
233  xmacptr_flag_recursive_lock,  /* recursive-lock */
234  xmacptr_flag_ptr,             /* malloc/free */
235  xmacptr_flag_rwlock,          /* read/write lock */
236  xmacptr_flag_semaphore,        /* semaphore */
237  xmacptr_flag_user_first = 8,  /* first user-defined dispose fn */
238  xmacptr_flag_user_last = 16   /* exclusive upper bound */
239} xmacptr_flag;
240
241
242typedef void (*xmacptr_dispose_fn)(void *);
243
244extern xmacptr_dispose_fn xmacptr_dispose_functions[];
245
246extern bitvector global_mark_ref_bits, dynamic_mark_ref_bits, relocatable_mark_ref_bits;
247
248
249#endif                          /* __GC_H__ */
Note: See TracBrowser for help on using the repository browser.