1.0.5.36: x86 allocation cleanup
[sbcl.git] / src / runtime / gencgc-internal.h
1 /*
2  * Generational Conservative Garbage Collector for SBCL x86
3  *
4  * inline functions that gc-common.c needs sight of
5  */
6
7
8 /*
9  * This software is part of the SBCL system. See the README file for
10  * more information.
11  *
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.
17  */
18
19 #ifndef _GENCGC_INTERNAL_H_
20 #define _GENCGC_INTERNAL_H_
21
22 #include <limits.h>
23 #include "gc.h"
24 #include "gencgc-alloc-region.h"
25 #include "genesis/code.h"
26
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 *);
31 \f
32
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.
37  *
38  * FIXME: We should probably just define this structure in Lisp, and
39  * output the C version in genesis. -- JES, 2006-12-30.
40  */
41 struct page {
42     /* The name of this field is not well-chosen for its actual use.
43      * This is the offset from the start of the page to the start
44      * of the alloc_region which contains/contained it.  It's negative or 0
45      */
46     long  first_object_offset;
47
48     /* the number of bytes of this page that are used. This may be less
49      * than the actual bytes used for pages within the current
50      * allocation regions. It should be 0 for all unallocated pages (not
51      * hard to achieve).
52      */
53 #if PAGE_BYTES > USHRT_MAX
54     unsigned int bytes_used;
55 #else
56     unsigned short bytes_used;
57 #endif
58
59     unsigned
60         /* This is set when the page is write-protected. This should
61          * always reflect the actual write_protect status of a page.
62          * (If the page is written into, we catch the exception, make
63          * the page writable, and clear this flag.) */
64         write_protected :1,
65         /* This flag is set when the above write_protected flag is
66          * cleared by the SIGBUS handler (or SIGSEGV handler, for some
67          * OSes). This is useful for re-scavenging pages that are
68          * written during a GC. */
69         write_protected_cleared :1,
70         /* the region the page is allocated to: 0 for a free page; 1
71          * for boxed objects; 2 for unboxed objects. If the page is
72          * free the following slots are invalid (well the bytes_used
73          * must be 0). */
74         allocated :3,
75         /* If this page should not be moved during a GC then this flag
76          * is set. It's only valid during a GC for allocated pages. */
77         dont_move :1,
78         /* If the page is part of a large object then this flag is
79          * set. No other objects should be allocated to these pages.
80          * This is only valid when the page is allocated. */
81         large_object :1,
82         /* True if the page is known to contain only zeroes. */
83         need_to_zero :1;
84
85     /* the generation that this page belongs to. This should be valid
86      * for all pages that may have objects allocated, even current
87      * allocation region pages - this allows the space of an object to
88      * be easily determined. */
89     generation_index_t gen;
90 };
91
92
93 /* values for the page.allocated field */
94
95 \f
96 extern unsigned page_table_pages;
97 extern struct page *page_table;
98
99 \f
100 /* forward declarations */
101
102 void sniff_code_object(struct code *code, unsigned long displacement);
103 void gencgc_apply_code_fixups(struct code *old_code, struct code *new_code);
104
105 long update_dynamic_space_free_pointer(void);
106 void gc_alloc_update_page_tables(int unboxed,
107                                  struct alloc_region *alloc_region);
108 void gc_alloc_update_all_page_tables(void);
109 void gc_set_region_empty(struct alloc_region *region);
110
111 /*
112  * predicates
113  */
114 static inline boolean
115 space_matches_p(lispobj obj, generation_index_t space)
116 {
117     page_index_t page_index=(void*)obj - (void *)DYNAMIC_SPACE_START;
118     return ((page_index >= 0)
119             && ((page_index =
120                  ((unsigned long)page_index)/PAGE_BYTES) < page_table_pages)
121             && (page_table[page_index].gen == space));
122 }
123
124 static inline boolean
125 from_space_p(lispobj obj)
126 {
127     return space_matches_p(obj,from_space);
128 }
129
130 static inline boolean
131 new_space_p(lispobj obj)
132 {
133     return space_matches_p(obj,new_space);
134 }
135
136 extern page_index_t last_free_page;
137 extern boolean gencgc_partial_pickup;
138
139 #endif