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 #if GENCGC_CARD_BYTES > USHRT_MAX
  34 # if GENCGC_CARD_BYTES > UINT_MAX
  35 #   error "GENCGC_CARD_BYTES unexpectedly large."
  36 # else
  37 typedef unsigned int page_bytes_t;
  38 # endif
  39 #else
  40 typedef unsigned short page_bytes_t;
  41 #endif
  42
  43 /* Note that this structure is also used from Lisp-side in
  44  * src/code/room.lisp, and the Lisp-side structure layout is currently
  45  * not groveled from C code but hardcoded. Any changes to the
  46  * structure layout need to be also made there.
  47  *
  48  * FIXME: We should probably just define this structure in Lisp, and
  49  * output the C version in genesis. -- JES, 2006-12-30.
  50  */
  51 struct page {
  52     /* This is the offset from the start of the page to the start of
  53      * the alloc_region which contains/contained it.
  54      */
  55     os_vm_size_t region_start_offset;
  56
  57     /* the number of bytes of this page that are used. This may be less
  58      * than the actual bytes used for pages within the current
  59      * allocation regions. It should be 0 for all unallocated pages (not
  60      * hard to achieve).
  61      */
  62     page_bytes_t bytes_used;
  63
  64     unsigned
  65         /* This is set when the page is write-protected. This should
  66          * always reflect the actual write_protect status of a page.
  67          * (If the page is written into, we catch the exception, make
  68          * the page writable, and clear this flag.) */
  69         write_protected :1,
  70         /* This flag is set when the above write_protected flag is
  71          * cleared by the SIGBUS handler (or SIGSEGV handler, for some
  72          * OSes). This is useful for re-scavenging pages that are
  73          * written during a GC. */
  74         write_protected_cleared :1,
  75         /*  000 free
  76          *  10? boxed data
  77          *  11? boxed code
  78          *  01? unboxed data
  79          *  ??1 open region
  80          *
  81          * If the page is free the following slots are invalid, except
  82          * for the bytes_used which must be zero. */
  83         allocated :3,
  84         /* If this page should not be moved during a GC then this flag
  85          * is set. It's only valid during a GC for allocated pages. */
  86         dont_move :1,
  87         /* If the page is part of a large object then this flag is
  88          * set. No other objects should be allocated to these pages.
  89          * This is only valid when the page is allocated. */
  90         large_object :1,
  91         /* Cleared if the page is known to contain only zeroes. */
  92         need_to_zero :1;
  93
  94     /* the generation that this page belongs to. This should be valid
  95      * for all pages that may have objects allocated, even current
  96      * allocation region pages - this allows the space of an object to
  97      * be easily determined. */
  98     generation_index_t gen;
  99 };
 100
 101
 102 /* values for the page.allocated field */
 103
 104 \f
 105 extern page_index_t page_table_pages;
 106 extern struct page *page_table;
 107
 108 \f
 109 /* forward declarations */
 110
 111 void sniff_code_object(struct code *code, unsigned long displacement);
 112 void gencgc_apply_code_fixups(struct code *old_code, struct code *new_code);
 113
 114 long update_dynamic_space_free_pointer(void);
 115 void gc_alloc_update_page_tables(int page_type_flag, struct alloc_region *alloc_region);
 116 void gc_alloc_update_all_page_tables(void);
 117 void gc_set_region_empty(struct alloc_region *region);
 118
 119 /*
 120  * predicates
 121  */
 122
 123 static inline boolean
 124 space_matches_p(lispobj obj, generation_index_t space)
 125 {
 126     if (obj >= DYNAMIC_SPACE_START) {
 127         page_index_t page_index=((pointer_sized_uint_t)obj
 128                                  - DYNAMIC_SPACE_START) / GENCGC_CARD_BYTES;
 129         return ((page_index < page_table_pages) &&
 130                 (page_table[page_index].gen == space));
 131     } else {
 132         return 0;
 133     }
 134 }
 135
 136 static inline boolean
 137 from_space_p(lispobj obj)
 138 {
 139     return space_matches_p(obj,from_space);
 140 }
 141
 142 static inline boolean
 143 new_space_p(lispobj obj)
 144 {
 145     return space_matches_p(obj,new_space);
 146 }
 147
 148 extern page_index_t last_free_page;
 149 extern boolean gencgc_partial_pickup;
 150
 151 #endif