2 * Generational Conservative Garbage Collector for SBCL x86
4 * inline functions that gc-common.c needs sight of
9 * This software is part of the SBCL system. See the README file for
12 * This software is derived from the CMU CL system, which was
13 * written at Carnegie Mellon University and released into the
14 * public domain. The software is in the public domain and is
15 * provided with absolutely no warranty. See the COPYING and CREDITS
16 * files for more information.
19 #ifndef _GENCGC_INTERNAL_H_
20 #define _GENCGC_INTERNAL_H_
24 #include "gencgc-alloc-region.h"
25 #include "genesis/code.h"
27 void gc_free_heap(void);
28 inline page_index_t find_page_index(void *);
29 inline void *page_address(page_index_t);
30 int gencgc_handle_wp_violation(void *);
33 /* Note that this structure is also used from Lisp-side in
34 * src/code/room.lisp, and the Lisp-side structure layout is currently
35 * not groveled from C code but hardcoded. Any changes to the
36 * structure layout need to be also made there.
38 * FIXME: We should probably just define this structure in Lisp, and
39 * output the C version in genesis. -- JES, 2006-12-30.
42 /* This is the offset from the start of the page to the start of
43 * the alloc_region which contains/contained it.
45 unsigned long region_start_offset;
47 /* the number of bytes of this page that are used. This may be less
48 * than the actual bytes used for pages within the current
49 * allocation regions. It should be 0 for all unallocated pages (not
52 #if PAGE_BYTES > USHRT_MAX
53 unsigned int bytes_used;
55 unsigned short bytes_used;
59 /* This is set when the page is write-protected. This should
60 * always reflect the actual write_protect status of a page.
61 * (If the page is written into, we catch the exception, make
62 * the page writable, and clear this flag.) */
64 /* This flag is set when the above write_protected flag is
65 * cleared by the SIGBUS handler (or SIGSEGV handler, for some
66 * OSes). This is useful for re-scavenging pages that are
67 * written during a GC. */
68 write_protected_cleared :1,
75 * If the page is free the following slots are invalid, except
76 * for the bytes_used which must be zero. */
78 /* If this page should not be moved during a GC then this flag
79 * is set. It's only valid during a GC for allocated pages. */
81 /* If the page is part of a large object then this flag is
82 * set. No other objects should be allocated to these pages.
83 * This is only valid when the page is allocated. */
85 /* True if the page is known to contain only zeroes. */
88 /* the generation that this page belongs to. This should be valid
89 * for all pages that may have objects allocated, even current
90 * allocation region pages - this allows the space of an object to
91 * be easily determined. */
92 generation_index_t gen;
96 /* values for the page.allocated field */
99 extern page_index_t page_table_pages;
100 extern struct page *page_table;
103 /* forward declarations */
105 void sniff_code_object(struct code *code, unsigned long displacement);
106 void gencgc_apply_code_fixups(struct code *old_code, struct code *new_code);
108 long update_dynamic_space_free_pointer(void);
109 void gc_alloc_update_page_tables(int page_type_flag, struct alloc_region *alloc_region);
110 void gc_alloc_update_all_page_tables(void);
111 void gc_set_region_empty(struct alloc_region *region);
117 static inline boolean
118 space_matches_p(lispobj obj, generation_index_t space)
120 if (obj >= DYNAMIC_SPACE_START) {
121 page_index_t page_index=((pointer_sized_uint_t)obj
122 - DYNAMIC_SPACE_START) / PAGE_BYTES;
123 return ((page_index < page_table_pages) &&
124 (page_table[page_index].gen == space));
130 static inline boolean
131 from_space_p(lispobj obj)
133 return space_matches_p(obj,from_space);
136 static inline boolean
137 new_space_p(lispobj obj)
139 return space_matches_p(obj,new_space);
142 extern page_index_t last_free_page;
143 extern boolean gencgc_partial_pickup;