X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fgc-internal.h;h=b91639688d1ff17b5ea6a534f6868506d0c82f34;hb=HEAD;hp=114f5142eda178b7cf64450b053749b81b37d3c6;hpb=63817d29028c8551cda23f432a3328acd7fdd62f;p=sbcl.git diff --git a/src/runtime/gc-internal.h b/src/runtime/gc-internal.h index 114f514..b916396 100644 --- a/src/runtime/gc-internal.h +++ b/src/runtime/gc-internal.h @@ -16,27 +16,51 @@ #ifndef _GC_INTERNAL_H_ #define _GC_INTERNAL_H_ +#include +#include "thread.h" +#include "interr.h" + +#ifdef LISP_FEATURE_GENCGC +#include "gencgc-internal.h" +#else +#include "cheneygc-internal.h" +#endif + /* disabling gc assertions made no discernable difference to GC speed, - * last I tried it - dan 2003.12.21 */ + * last I tried it - dan 2003.12.21 + * + * And it's unsafe to do so while things like gc_assert(0 == + * thread_mutex_lock(&allocation_lock)) exist. - MG 2009-01-13 + */ #if 1 -#define gc_assert(ex) do { \ - if (!(ex)) gc_abort(); \ +# define gc_assert(ex) \ +do { \ + if (!(ex)) gc_abort(); \ +} while (0) +# define gc_assert_verbose(ex, fmt, ...) \ +do { \ + if (!(ex)) { \ + fprintf(stderr, fmt, ## __VA_ARGS__); \ + gc_abort(); \ + } \ } while (0) #else -#define gc_assert(ex) +# define gc_assert(ex) +# define gc_assert_verbose(ex, fmt, ...) #endif -#define gc_abort() lose("GC invariant lost, file \"%s\", line %d", \ - __FILE__, __LINE__) + +#define gc_abort() \ + lose("GC invariant lost, file \"%s\", line %d\n", __FILE__, __LINE__) #define CEILING(x,y) (((x) + ((y) - 1)) & (~((y) - 1))) -static inline unsigned int -NWORDS(unsigned int x, unsigned int n_bits) +static inline uword_t +NWORDS(uword_t x, uword_t n_bits) { /* A good compiler should be able to constant-fold this whole thing, even with the conditional. */ if(n_bits <= N_WORD_BITS) { - unsigned int elements_per_word = N_WORD_BITS/n_bits; + uword_t elements_per_word = N_WORD_BITS/n_bits; return CEILING(x, elements_per_word)/elements_per_word; } @@ -48,73 +72,98 @@ NWORDS(unsigned int x, unsigned int n_bits) } /* FIXME: Shouldn't this be defined in sbcl.h? */ -#define FUN_RAW_ADDR_OFFSET (6*sizeof(lispobj) - FUN_POINTER_LOWTAG) -/* values for the *_alloc_* parameters */ +#if defined(LISP_FEATURE_SPARC) +#define FUN_RAW_ADDR_OFFSET 0 +#else +#define FUN_RAW_ADDR_OFFSET (offsetof(struct simple_fun, code) - FUN_POINTER_LOWTAG) +#endif + +/* values for the *_alloc_* parameters, also see the commentary for + * struct page in gencgc-internal.h. FIXME: Perhaps these constants + * should be there, or at least defined on gencgc only? */ #define FREE_PAGE_FLAG 0 #define BOXED_PAGE_FLAG 1 #define UNBOXED_PAGE_FLAG 2 #define OPEN_REGION_PAGE_FLAG 4 +#define CODE_PAGE_FLAG (BOXED_PAGE_FLAG|UNBOXED_PAGE_FLAG) #define ALLOC_BOXED 0 #define ALLOC_UNBOXED 1 #define ALLOC_QUICK 1 -void *gc_general_alloc(int nbytes,int unboxed_p,int quick_p); +#ifdef LISP_FEATURE_GENCGC +#include "gencgc-alloc-region.h" +void * +gc_alloc_with_region(sword_t nbytes,int page_type_flag, struct alloc_region *my_region, + int quick_p); +static inline void * +gc_general_alloc(sword_t nbytes, int page_type_flag, int quick_p) +{ + struct alloc_region *my_region; + if (UNBOXED_PAGE_FLAG == page_type_flag) { + my_region = &unboxed_region; + } else if (BOXED_PAGE_FLAG & page_type_flag) { + my_region = &boxed_region; + } else { + lose("bad page type flag: %d", page_type_flag); + } + return gc_alloc_with_region(nbytes, page_type_flag, my_region, quick_p); +} +#else +extern void *gc_general_alloc(word_t nbytes,int page_type_flag,int quick_p); +#endif + +static inline lispobj +gc_general_copy_object(lispobj object, long nwords, int page_type_flag) +{ + lispobj *new; + + gc_assert(is_lisp_pointer(object)); + gc_assert(from_space_p(object)); + gc_assert((nwords & 0x01) == 0); + + /* Allocate space. */ + new = gc_general_alloc(nwords*N_WORD_BYTES, page_type_flag, ALLOC_QUICK); + + /* Copy the object. */ + memcpy(new,native_pointer(object),nwords*N_WORD_BYTES); + + return make_lispobj(new, lowtag_of(object)); +} -extern int (*scavtab[256])(lispobj *where, lispobj object); +extern sword_t (*scavtab[256])(lispobj *where, lispobj object); extern lispobj (*transother[256])(lispobj object); -extern int (*sizetab[256])(lispobj *where); +extern sword_t (*sizetab[256])(lispobj *where); extern struct weak_pointer *weak_pointers; /* in gc-common.c */ +extern struct hash_table *weak_hash_tables; /* in gc-common.c */ -extern void scavenge(lispobj *start, long n_words); +extern void scavenge(lispobj *start, sword_t n_words); +extern void scavenge_interrupt_contexts(struct thread *thread); +extern void scav_weak_hash_tables(void); +extern void scan_weak_hash_tables(void); extern void scan_weak_pointers(void); -lispobj copy_large_unboxed_object(lispobj object, int nwords); -lispobj copy_unboxed_object(lispobj object, int nwords); -lispobj copy_large_object(lispobj object, int nwords); -lispobj copy_object(lispobj object, int nwords); +lispobj copy_large_unboxed_object(lispobj object, sword_t nwords); +lispobj copy_unboxed_object(lispobj object, sword_t nwords); +lispobj copy_large_object(lispobj object, sword_t nwords); +lispobj copy_object(lispobj object, sword_t nwords); +lispobj copy_code_object(lispobj object, sword_t nwords); lispobj *search_read_only_space(void *pointer); lispobj *search_static_space(void *pointer); lispobj *search_dynamic_space(void *pointer); -#include "fixnump.h" +lispobj *gc_search_space(lispobj *start, size_t words, lispobj *pointer); -/* Scan an area looking for an object which encloses the given pointer. - * Return the object start on success or NULL on failure. */ -static lispobj * -search_space(lispobj *start, size_t words, lispobj *pointer) -{ - while (words > 0) { - size_t count = 1; - lispobj thing = *start; - - /* If thing is an immediate then this is a cons. */ - if (is_lisp_pointer(thing) - || (fixnump(thing)) - || (widetag_of(thing) == CHARACTER_WIDETAG) - || (widetag_of(thing) == UNBOUND_MARKER_WIDETAG)) - count = 2; - else - count = (sizetab[widetag_of(thing)])(start); - - /* Check whether the pointer is within this object. */ - if ((pointer >= start) && (pointer < (start+count))) { - /* found it! */ - /*FSHOW((stderr,"/found %x in %x %x\n", pointer, start, thing));*/ - return(start); - } - - /* Round up the count. */ - count = CEILING(count,2); - - start += count; - words -= count; - } - return (NULL); -} +extern int looks_like_valid_lisp_pointer_p(lispobj pointer, lispobj *start_addr); + +extern void scavenge_control_stack(struct thread *th); +extern void scrub_control_stack(void); +extern void scrub_thread_control_stack(struct thread *); + +#include "fixnump.h" #ifdef LISP_FEATURE_GENCGC #include "gencgc-internal.h" @@ -122,4 +171,10 @@ search_space(lispobj *start, size_t words, lispobj *pointer) #include "cheneygc-internal.h" #endif +#if N_WORD_BITS == 32 +# define SIMPLE_ARRAY_WORD_WIDETAG SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG +#elif N_WORD_BITS == 64 +# define SIMPLE_ARRAY_WORD_WIDETAG SIMPLE_ARRAY_UNSIGNED_BYTE_64_WIDETAG +#endif + #endif /* _GC_INTERNAL_H_ */