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 struct page {
  33     /* The name of this field is not well-chosen for its actual use.
  34      * This is the offset from the start of the page to the start
  35      * of the alloc_region which contains/contained it.  It's negative or 0
  36      */
  37     long  first_object_offset;
  38
  39     /* the number of bytes of this page that are used. This may be less
  40      * than the actual bytes used for pages within the current
  41      * allocation regions. It should be 0 for all unallocated pages (not
  42      * hard to achieve).
  43      *
  44      * Currently declared as an unsigned short to make the struct size
  45      * smaller. This means that GENCGC-PAGE-SIZE is constrained to fit
  46      * inside a short.
  47      */
  48     unsigned short bytes_used;
  49
  50 #if USHRT_MAX < PAGE_BYTES
  51 #error "PAGE_BYTES too large"
  52 #endif
  53
  54     unsigned
  55         /* This is set when the page is write-protected. This should
  56          * always reflect the actual write_protect status of a page.
  57          * (If the page is written into, we catch the exception, make
  58          * the page writable, and clear this flag.) */
  59         write_protected :1,
  60         /* This flag is set when the above write_protected flag is
  61          * cleared by the SIGBUS handler (or SIGSEGV handler, for some
  62          * OSes). This is useful for re-scavenging pages that are
  63          * written during a GC. */
  64         write_protected_cleared :1,
  65         /* the region the page is allocated to: 0 for a free page; 1
  66          * for boxed objects; 2 for unboxed objects. If the page is
  67          * free the following slots are invalid (well the bytes_used
  68          * must be 0). */
  69         allocated :3,
  70         /* If this page should not be moved during a GC then this flag
  71          * is set. It's only valid during a GC for allocated pages. */
  72         dont_move :1,
  73         /* If the page is part of a large object then this flag is
  74          * set. No other objects should be allocated to these pages.
  75          * This is only valid when the page is allocated. */
  76         large_object :1,
  77         /* True if the page is known to contain only zeroes. */
  78         need_to_zero :1;
  79
  80     /* the generation that this page belongs to. This should be valid
  81      * for all pages that may have objects allocated, even current
  82      * allocation region pages - this allows the space of an object to
  83      * be easily determined. */
  84     generation_index_t gen;
  85 };
  86
  87
  88 /* values for the page.allocated field */
  89
  90 \f
  91 extern unsigned page_table_pages;
  92 extern struct page *page_table;
  93
  94 \f
  95 /* forward declarations */
  96
  97 void sniff_code_object(struct code *code, unsigned long displacement);
  98 void gencgc_apply_code_fixups(struct code *old_code, struct code *new_code);
  99
 100 long update_dynamic_space_free_pointer(void);
 101 void gc_alloc_update_page_tables(int unboxed,
 102                                  struct alloc_region *alloc_region);
 103 void gc_alloc_update_all_page_tables(void);
 104 void gc_set_region_empty(struct alloc_region *region);
 105
 106 /*
 107  * predicates
 108  */
 109 static inline boolean
 110 space_matches_p(lispobj obj, generation_index_t space)
 111 {
 112     page_index_t page_index=(void*)obj - (void *)DYNAMIC_SPACE_START;
 113     return ((page_index >= 0)
 114             && ((page_index =
 115                  ((unsigned long)page_index)/PAGE_BYTES) < page_table_pages)
 116             && (page_table[page_index].gen == space));
 117 }
 118
 119 static inline boolean
 120 from_space_p(lispobj obj)
 121 {
 122     return space_matches_p(obj,from_space);
 123 }
 124
 125 static inline boolean
 126 new_space_p(lispobj obj)
 127 {
 128     return space_matches_p(obj,new_space);
 129 }
 130
 131 extern page_index_t last_free_page;
 132 extern boolean gencgc_partial_pickup;
 133
 134 #endif