From: William Harold Newman Date: Wed, 18 Oct 2000 23:08:20 +0000 (+0000) Subject: 0.6.7.15: control_stack stuff redone as Lisp/C constants X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=5f338d314224411587a7cac218ea320bc982f19f;p=sbcl.git 0.6.7.15: control_stack stuff redone as Lisp/C constants --- diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr index 1e70963..6d7d1a5 100644 --- a/package-data-list.lisp-expr +++ b/package-data-list.lisp-expr @@ -1689,7 +1689,7 @@ structure representations" "SYMBOL-RAW-FUNCTION-ADDR-SLOT" "SYMBOL-SETF-FUNCTION-SLOT" "SYMBOL-SIZE" "SYMBOL-UNUSED-SLOT" "SYMBOL-VALUE-SLOT" "BINDING-STACK-START" "TARGET-BYTE-ORDER" - "CONTROL-STACK-START" "DYNAMIC-SPACE-START" + "CONTROL-STACK-START" "CONTROL-STACK-END" "DYNAMIC-SPACE-START" "TARGET-FASL-CODE-FORMAT" "TARGET-FASL-FILE-TYPE" "TARGET-HEAP-ADDRESS-SPACE" "*TARGET-MOST-NEGATIVE-FIXNUM*" "*TARGET-MOST-POSITIVE-FIXNUM*" "READ-ONLY-SPACE-START" diff --git a/src/code/debug-int.lisp b/src/code/debug-int.lisp index b729c2b..42ab7e8 100644 --- a/src/code/debug-int.lisp +++ b/src/code/debug-int.lisp @@ -674,18 +674,15 @@ #!-sb-fluid (declaim (inline cstack-pointer-valid-p)) (defun cstack-pointer-valid-p (x) (declare (type system-area-pointer x)) - #!-x86 + #!-x86 ; stack grows toward high address values (and (sap< x (current-sp)) - (sap<= #!-gengc (sb!alien:alien-sap - (sb!alien:extern-alien "control_stack" (* t))) + (sap<= #!-gengc (int-sap control-stack-start) #!+gengc (mutator-control-stack-base) x) (zerop (logand (sap-int x) #b11))) - #!+x86 ;; stack grows to low address values + #!+x86 ; stack grows toward low address values (and (sap>= x (current-sp)) - (sap> (sb!alien:alien-sap (sb!alien:extern-alien "control_stack_end" - (* t))) - x) + (sap> (int-sap control-stack-end) x) (zerop (logand (sap-int x) #b11)))) #!+(or gengc x86) @@ -729,9 +726,7 @@ ;; Not the first page which is unmapped. (>= (sap-int ra) 4096) ;; Not a Lisp stack pointer. - (or (sap< ra (current-sp)) - (sap>= ra (sb!alien:alien-sap - (sb!alien:extern-alien "control_stack_end" (* t))))))) + (not (cstack-pointer-valid-p ra)))) ;;; Try to find a valid previous stack. This is complex on the x86 as ;;; it can jump between C and Lisp frames. To help find a valid frame diff --git a/src/code/gc.lisp b/src/code/gc.lisp index c87ebed..a2ad5f5 100644 --- a/src/code/gc.lisp +++ b/src/code/gc.lisp @@ -26,9 +26,6 @@ (defun ,lisp-fun () (sb!alien:extern-alien ,c-var-name (sb!alien:unsigned 32)))))) -(def-c-var-frob sb!vm:control-stack-start "control_stack") -#!+x86 (def-c-var-frob control-stack-end "control_stack_end") - #!-sb-fluid (declaim (inline dynamic-usage)) (def-c-var-frob dynamic-usage "bytes_allocated") @@ -42,8 +39,8 @@ (defun control-stack-usage () #!-x86 (- (sb!sys:sap-int (sb!c::control-stack-pointer-sap)) - (control-stack-start)) - #!+x86 (- (control-stack-end) + control-stack-start) + #!+x86 (- control-stack-end (sb!sys:sap-int (sb!c::control-stack-pointer-sap)))) (defun binding-stack-usage () diff --git a/src/compiler/generic/objdef.lisp b/src/compiler/generic/objdef.lisp index 33e9db3..a8064ad 100644 --- a/src/compiler/generic/objdef.lisp +++ b/src/compiler/generic/objdef.lisp @@ -245,43 +245,6 @@ ;;; (For an explanation of this, see the comments at the definition of ;;; KLUDGE-NONDETERMINISTIC-CATCH-BLOCK-SIZE.) (assert (= sb!vm::kludge-nondeterministic-catch-block-size catch-block-size)) - -#!+gengc -(define-primitive-object (mutator) - ;; Holds the lisp thread structure, if any. - (thread) - ;; Signal control magic. - (foreign-fn-call-active :c-type "boolean") - (interrupts-disabled-count :c-type "int") - (interrupt-pending :c-type "boolean") - (pending-signal :c-type "int") - (pending-code :c-type "int") - (pending-mask :c-type "int") - (gc-pending :c-type "boolean") - ;; Stacks. - (control-stack-base :c-type "lispobj *") - (control-stack-pointer :c-type "lispobj *") - (control-stack-end :c-type "lispobj *") - (control-frame-pointer :c-type "lispobj *") - (current-unwind-protect :c-type "struct unwind_block *") - (current-catch-block :c-type "struct catch_block *") - (binding-stack-base :c-type "struct binding *") - (binding-stack-pointer :c-type "struct binding *") - (binding-stack-end :c-type "struct binding *") - (number-stack-base :c-type "char *") - (number-stack-pointer :c-type "char *") - (number-stack-end :c-type "char *") - (eval-stack) - (eval-stack-top) - ;; Allocation stuff. - (nursery-start :c-type "lispobj *") - (nursery-fill-pointer :c-type "lispobj *") - (nursery-end :c-type "lispobj *") - (storebuf-start :c-type "lispobj **") - (storebuf-fill-pointer :c-type "lispobj **") - (storebuf-end :c-type "lispobj **") - (words-consed :c-type "unsigned long")) - ;;;; symbols @@ -289,11 +252,11 @@ (defknown %make-symbol (index simple-string) symbol (flushable movable)) -#+gengc +#!+gengc (defknown symbol-hash (symbol) index (flushable movable)) -#+x86 +#!+x86 (defknown symbol-hash (symbol) (integer 0 #.*target-most-positive-fixnum*) (flushable movable)) diff --git a/src/compiler/x86/parms.lisp b/src/compiler/x86/parms.lisp index 4027530..9a65bfc 100644 --- a/src/compiler/x86/parms.lisp +++ b/src/compiler/x86/parms.lisp @@ -123,25 +123,45 @@ ;;; duplicated between this file and runtime/x86-validate.h. ;;; ;;; Note: Mostly these values are black magic, inherited from CMU CL -;;; without any documentation. However, there have been a few changes -;;; since the fork: -;;; * The FreeBSD STATIC-SPACE-START value was bumped up -;;; from #x28000000 to #x30000000 when FreeBSD ld.so dynamic linking +;;; without any documentation. However, there were a few explanatory +;;; comments in the CMU CL sources: +;;; * On Linux, +;;; ** The space 0x08000000-0x10000000 is "C program and memory allocation". +;;; ** The space 0x40000000-0x48000000 is reserved for shared libs. +;;; ** The space >0xE0000000 is "C stack - Alien stack". +;;; * On FreeBSD, +;;; ** The space 0x0E000000-0x10000000 is "Foreign segment". +;;; ** The space 0x20000000-0x30000000 is reserved for shared libs. +;;; And there have been a few changes since the fork: +;;; * The FreeBSD STATIC-SPACE-START value was bumped up from +;;; #x28000000 to #x30000000 when FreeBSD ld.so dynamic linking ;;; support was added for FreeBSD ca. 20000910. This was to keep from ;;; stomping on an address range that the dynamic libraries want to use. ;;; (They want to use this address range even if we try to reserve it ;;; with a call to validate() as the first operation in main().) #!+linux (progn + (defconstant read-only-space-start #x01000000) + (defconstant static-space-start #x05000000) - (defconstant dynamic-space-start #x09000000)) + + (defconstant dynamic-space-start #x09000000) + + (defconstant control-stack-start #x50000000) + (defconstant control-stack-end #x57fff000)) #!+bsd (progn + (defconstant read-only-space-start #x10000000) + (defconstant static-space-start #!+freebsd #x30000000 #!+openbsd #x28000000) + + (defconstant control-stack-start #x40000000) + (defconstant control-stack-end #x07fff000) + (defconstant dynamic-space-start #x48000000)) ;;; Given that NIL is the first thing allocated in static space, we diff --git a/src/compiler/x86/type-vops.lisp b/src/compiler/x86/type-vops.lisp index 6a53827..273ef27 100644 --- a/src/compiler/x86/type-vops.lisp +++ b/src/compiler/x86/type-vops.lisp @@ -109,7 +109,7 @@ ;;; Emit the most compact form of the test immediate instruction, ;;; using an 8 bit test when the immediate is only 8 bits and the ;;; value is one of the four low registers (eax, ebx, ecx, edx) or the -;;; control-stack. +;;; control stack. (defun generate-fixnum-test (value) (let ((offset (tn-offset value))) (cond ((and (sc-is value any-reg descriptor-reg) diff --git a/src/runtime/backtrace.c b/src/runtime/backtrace.c index a7ebb37..7e58e80 100644 --- a/src/runtime/backtrace.c +++ b/src/runtime/backtrace.c @@ -94,8 +94,9 @@ code_pointer(lispobj object) static boolean cs_valid_pointer_p(struct call_frame *pointer) { - return (((char *) control_stack <= (char *) pointer) && - ((char *) pointer < (char *) current_control_stack_pointer)); + lose("stub: hasn't been updated for X86"); + return (((char *) CONTROL_STACK_START <= (char *) pointer) && + ((char *) pointer < (char *) current_control_stack_pointer)); } static void diff --git a/src/runtime/gencgc.c b/src/runtime/gencgc.c index 045a722..a217142 100644 --- a/src/runtime/gencgc.c +++ b/src/runtime/gencgc.c @@ -4604,19 +4604,19 @@ scavenge_thread_stacks(void) vector_length)); if (vector_length > 0) { lispobj *stack_pointer = (lispobj*)stack->data[0]; - if ((stack_pointer < control_stack) || - (stack_pointer > control_stack_end)) + if ((stack_pointer < (lispobj *)CONTROL_STACK_START) || + (stack_pointer > (lispobj *)CONTROL_STACK_END)) lose("invalid stack pointer %x", (unsigned)stack_pointer); - if ((stack_pointer > control_stack) && - (stack_pointer < control_stack_end)) { + if ((stack_pointer > (lispobj *)CONTROL_STACK_START) && + (stack_pointer < (lispobj *)CONTROL_STACK_END)) { /* FIXME: Ick! * (1) hardwired word length = 4; and as usual, * when fixing this, check for other places * with the same problem * (2) calling it 'length' suggests bytes; * perhaps 'size' instead? */ - unsigned int length = ((unsigned)control_stack_end - + unsigned int length = ((unsigned)CONTROL_STACK_END - (unsigned)stack_pointer) / 4; int j; if (length >= vector_length) { @@ -5663,9 +5663,11 @@ garbage_collect_generation(int generation, int raise) /* Scavenge the stack's conservative roots. */ { lispobj **ptr; - for (ptr = (lispobj **)CONTROL_STACK_END-1; - ptr > (lispobj **)&raise; ptr--) + for (ptr = (lispobj **)CONTROL_STACK_END - 1; + ptr > (lispobj **)&raise; + ptr--) { preserve_pointer(*ptr); + } } #ifdef CONTROL_STACKS scavenge_thread_stacks(); diff --git a/src/runtime/globals.c b/src/runtime/globals.c index ae67e71..577d7c6 100644 --- a/src/runtime/globals.c +++ b/src/runtime/globals.c @@ -31,11 +31,6 @@ lispobj *current_control_frame_pointer; lispobj *current_binding_stack_pointer; #endif -lispobj *control_stack; -#ifdef __i386__ -lispobj *control_stack_end; -#endif - #ifndef ALLOCATION_POINTER lispobj *dynamic_space_free_pointer; #endif @@ -58,9 +53,9 @@ void globals_init(void) /* Initialize the current Lisp state. */ #ifndef __i386__ - current_control_stack_pointer = control_stack; + current_control_stack_pointer = (lispobj *)CONTROL_STACK_START; #else - current_control_stack_pointer = control_stack_end; + current_control_stack_pointer = (lispobj *)CONTROL_STACK_END; #endif current_control_frame_pointer = (lispobj *)0; diff --git a/src/runtime/globals.h b/src/runtime/globals.h index 695e644..4d956c8 100644 --- a/src/runtime/globals.h +++ b/src/runtime/globals.h @@ -28,10 +28,6 @@ extern lispobj *current_control_frame_pointer; extern lispobj *current_binding_stack_pointer; #endif -extern lispobj *control_stack; -#ifdef __i386__ -extern lispobj *control_stack_end; -#endif #if !defined(ibmrt) && !defined(__i386__) extern lispobj *dynamic_space_free_pointer; extern lispobj *current_auto_gc_trigger; diff --git a/src/runtime/linux-os.c b/src/runtime/linux-os.c index 76bb9ed..9d8ee0a 100644 --- a/src/runtime/linux-os.c +++ b/src/runtime/linux-os.c @@ -236,6 +236,9 @@ os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot) } } +/* FIXME: Now that FOO_END, rather than FOO_SIZE, is the fundamental + * description of a space, we could probably punt this and just do + * (FOO_START <= x && x < FOO_END) everywhere it's called. */ static boolean in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen) { diff --git a/src/runtime/purify.c b/src/runtime/purify.c index a8e7f85..677db6d 100644 --- a/src/runtime/purify.c +++ b/src/runtime/purify.c @@ -1401,8 +1401,8 @@ int purify(lispobj static_roots, lispobj read_only_roots) #endif #ifdef GENCGC - gc_assert(control_stack_end > ((&read_only_roots)+1)); - setup_i386_stack_scav(((&static_roots)-2), control_stack_end); + gc_assert((lispobj *)CONTROL_STACK_END > ((&read_only_roots)+1)); + setup_i386_stack_scav(((&static_roots)-2), (lispobj *)CONTROL_STACK_END); #endif pscav(&static_roots, 1, 0); @@ -1421,14 +1421,17 @@ int purify(lispobj static_roots, lispobj read_only_roots) fflush(stdout); #endif #ifndef __i386__ - pscav(control_stack, current_control_stack_pointer - control_stack, 0); + pscav((lispobj *)control_stack, + current_control_stack_pointer - (lispobj *)CONTROL_STACK_START, + 0); #else #ifdef GENCGC pscav_i386_stack(); #endif #ifdef WANT_CGC - gc_assert(control_stack_end > ((&read_only_roots)+1)); - carefully_pscav_stack(((&read_only_roots)+1), control_stack_end); + gc_assert((lispobj *)control_stack_end > ((&read_only_roots)+1)); + carefully_pscav_stack(((&read_only_roots)+1), + (lispobj *)CONTROL_STACK_END); #endif #endif @@ -1510,7 +1513,8 @@ int purify(lispobj static_roots, lispobj read_only_roots) #ifndef __i386__ os_zero((os_vm_address_t) current_control_stack_pointer, (os_vm_size_t) (CONTROL_STACK_SIZE - - ((current_control_stack_pointer - control_stack) * + ((current_control_stack_pointer - + (lispobj *)CONTROL_STACK_START) * sizeof(lispobj)))); #endif diff --git a/src/runtime/validate.c b/src/runtime/validate.c index d008f8d..5f31b20 100644 --- a/src/runtime/validate.c +++ b/src/runtime/validate.c @@ -64,19 +64,10 @@ void validate(void) #endif ensure_space(READ_ONLY_SPACE_START, READ_ONLY_SPACE_SIZE); - - ensure_space(STATIC_SPACE_START, STATIC_SPACE_SIZE); - - ensure_space(DYNAMIC_SPACE_START, DYNAMIC_SPACE_SIZE); - - control_stack = (lispobj *) CONTROL_STACK_START; -#ifdef __i386__ - control_stack_end = (lispobj *) (CONTROL_STACK_START - + CONTROL_STACK_SIZE); -#endif - ensure_space(control_stack, CONTROL_STACK_SIZE); - - ensure_space(BINDING_STACK_START, BINDING_STACK_SIZE); + ensure_space(STATIC_SPACE_START , STATIC_SPACE_SIZE); + ensure_space(DYNAMIC_SPACE_START , DYNAMIC_SPACE_SIZE); + ensure_space(CONTROL_STACK_START , CONTROL_STACK_SIZE); + ensure_space(BINDING_STACK_START , BINDING_STACK_SIZE); #ifdef HOLES make_holes(); diff --git a/src/runtime/x86-arch.c b/src/runtime/x86-arch.c index 3c556c4..5e307e3 100644 --- a/src/runtime/x86-arch.c +++ b/src/runtime/x86-arch.c @@ -219,7 +219,7 @@ sigtrap_handler(int signal, siginfo_t *info, void *void_context) /* This is just for info in case the monitor wants to print an * approximation. */ current_control_stack_pointer = - (lispobj*)*os_context_sp_addr(context); + (lispobj *)*os_context_sp_addr(context); /* On entry %eip points just after the INT3 byte and aims at the * 'kind' value (eg trap_Cerror). For error-trap and Cerror-trap a diff --git a/src/runtime/x86-validate.h b/src/runtime/x86-validate.h index e7cefb3..b86cd82 100644 --- a/src/runtime/x86-validate.h +++ b/src/runtime/x86-validate.h @@ -13,39 +13,6 @@ * $Header$ */ -/* - * address map: - * - * FreeBSD: - * 0x00000000->0x0E000000 224M C program and memory allocation. - * 0x0E000000->0x10000000 32M Foreign segment. - * 0x10000000->0x20000000 256M Read-Only Space. - * 0x20000000->0x30000000 256M Reserved for shared libraries. - * 0x30000000->0x38000000 128M Static Space. - * 0x38000000->0x40000000 128M Binding stack growing up. - * 0x40000000->0x48000000 128M Control stack growing down. - * 0x48000000->0xC8000000 2GB Dynamic Space. - * 0xE0000000-> 256M C stack - Alien stack. - * - * OpenBSD: - * almost the same as FreeBSD - * - * Linux: Note that this map has some problems and requires some further - * development so is not implemented below. - * 0x00000000->0x08000000 128M Unused. - * 0x08000000->0x10000000 128M C program and memory allocation. - * 0x10000000->0x20000000 256M Read-Only Space. - * 0x20000000->0x28000000 128M Binding stack growing up. - * 0x28000000->0x38000000 256M Static Space. - * 0x38000000->0x40000000 128M Control stack growing down. - * 0x40000000->0x48000000 128M Reserved for shared libraries. - * 0x48000000->0xB8000000 1.75G Dynamic Space. - * - * FIXME: There's something wrong with addressing maps which are so - * brittle that they can be commented as fixed addresses. Try to - * parameterize these so they can be set at build time. - */ - #if defined(__FreeBSD__) || defined(__OpenBSD__) #define READ_ONLY_SPACE_SIZE (0x0ffff000) /* 256MB - 1 page */ @@ -57,27 +24,12 @@ #error unsupported BSD variant #endif - #define BINDING_STACK_START (0x38000000) #define BINDING_STACK_SIZE (0x07fff000) /* 128MB - 1 page */ -#define CONTROL_STACK_START (0x40000000) -#define CONTROL_STACK_SIZE (0x08000000) /* 128MB */ - #define DYNAMIC_SPACE_SIZE (0x40000000) /* may be up to 2GB */ #endif -/* FIXME: It's gross to have numbers like 0x50000000 wired into the - * code in multiple places like this. (Not only does this file know - * about it, but Lisp code knows about it, because Lisp code is able - * to generate absolute addresses for all the static symbols even - * before it's read the map file.) I don't know whether I should - * actually *fix* this, but I should at least document it some with a - * KLUDGE marker. And it might even be fixable, by putting all this - * memory space arbitrariness into an architecture-dependent Lisp - * file. If so, perhaps I should write somewhere in a "design - * principles" or "coding principles" file that information like this - * always flows from Lisp code to C code, through sbcl.h. */ #ifdef __linux__ #define READ_ONLY_SPACE_SIZE (0x02800000) /* 40MB */ @@ -86,10 +38,7 @@ #define BINDING_STACK_START (0x60000000) #define BINDING_STACK_SIZE (0x07fff000) /* 128MB - 1 page */ -#define CONTROL_STACK_START (0x50000000) -#define CONTROL_STACK_SIZE (0x07fff000) /* 128MB - 1 page */ - #define DYNAMIC_SPACE_SIZE (0x20000000) /* 512MB */ #endif -#define CONTROL_STACK_END (CONTROL_STACK_START + CONTROL_STACK_SIZE) +#define CONTROL_STACK_SIZE (CONTROL_STACK_END - CONTROL_STACK_START) diff --git a/version.lisp-expr b/version.lisp-expr index 58ad964..06c680e 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -15,4 +15,4 @@ ;;; versions, and a string a la "0.6.5.12" is used for versions which ;;; aren't released but correspond only to CVS tags or snapshots. -"0.6.7.14" +"0.6.7.15"