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     /* This is the offset from the start of the page to the start of
  43      * the alloc_region which contains/contained it.
  44      */
  45     unsigned long region_start_offset;
  46
  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
  50      * hard to achieve).
  51      */
  52 #if PAGE_BYTES > USHRT_MAX
  53     unsigned int bytes_used;
  54 #else
  55     unsigned short bytes_used;
  56 #endif
  57
  58     unsigned
  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.) */
  63         write_protected :1,
  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,
  69         /*  000 free
  70          *  10? boxed data
  71          *  11? boxed code
  72          *  01? unboxed data
  73          *  ??1 open region
  74          *
  75          * If the page is free the following slots are invalid, except
  76          * for the bytes_used which must be zero. */
  77         allocated :3,
  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. */
  80         dont_move :1,
  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. */
  84         large_object :1,
  85         /* True if the page is known to contain only zeroes. */
  86         need_to_zero :1;
  87
  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;
  93 };
  94
  95
  96 /* values for the page.allocated field */
  97
  98 \f
  99 extern page_index_t page_table_pages;
 100 extern struct page *page_table;
 101
 102 \f
 103 /* forward declarations */
 104
 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);
 107
 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);
 112
 113 /*
 114  * predicates
 115  */
 116
 117 static inline boolean
 118 space_matches_p(lispobj obj, generation_index_t space)
 119 {
 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));
 125     } else {
 126         return 0;
 127     }
 128 }
 129
 130 static inline boolean
 131 from_space_p(lispobj obj)
 132 {
 133     return space_matches_p(obj,from_space);
 134 }
 135
 136 static inline boolean
 137 new_space_p(lispobj obj)
 138 {
 139     return space_matches_p(obj,new_space);
 140 }
 141
 142 extern page_index_t last_free_page;
 143 extern boolean gencgc_partial_pickup;
 144
 145 #endif