From: William Harold Newman Date: Mon, 11 Jun 2001 13:44:07 +0000 (+0000) Subject: 0.6.12.29: X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=0a7e5d543e632bfa478fd4a96b4d1f583c922553;p=sbcl.git 0.6.12.29: cleanups pending from flaky2_branch and SB!FASL-package adventures, part II (more deleting).. ..!COLD-INIT doesn't need to be a static symbol. ..Does FDEFINITION-OBJECT need to be a static symbol? No. ..Do we need the mysterious COLD-SETs of function values at the beginning of FINISH-SYMBOLS in genesis.lisp? No. ..fasl version number change since !COLD-INIT is gone from *STATIC-SYMBOLS* --- 0a7e5d543e632bfa478fd4a96b4d1f583c922553 diff --cc src/code/early-fasl.lisp index be0d3ab,0000000..e1eb072 mode 100644,000000..100644 --- a/src/code/early-fasl.lisp +++ b/src/code/early-fasl.lisp @@@ -1,135 -1,0 +1,136 @@@ +;;;; needed-early, or at least meaningful-early, stuff for FASL files + +;;;; This software is part of the SBCL system. See the README file for +;;;; more information. +;;;; +;;;; This software is derived from the CMU CL system, which was +;;;; written at Carnegie Mellon University and released into the +;;;; public domain. The software is in the public domain and is +;;;; provided with absolutely no warranty. See the COPYING and CREDITS +;;;; files for more information. + +(in-package "SB!FASL") + +;;;; various constants and essentially-constants + +;;; a string which appears at the start of a fasl file header +;;; +;;; This value is used to identify fasl files. Even though this is not +;;; declared as a constant (because ANSI Common Lisp has no facility +;;; for declaring values which are constant under EQUAL but not EQL), +;;; obviously you shouldn't mess with it lightly. If you do set a new +;;; value for some reason, keep these things in mind: +;;; * To avoid confusion with the similar but incompatible CMU CL +;;; fasl file format, the value should not be "FASL FILE", which +;;; is what CMU CL used for the same purpose. +;;; * Since its presence at the head of a file is used by LOAD to +;;; decide whether a file is to be fasloaded or just loaded +;;; ordinarily (as source), the value should be something which +;;; can't legally appear at the head of a Lisp source file. +;;; * The value should not contain any line-terminating characters, +;;; because they're hard to express portably and because the LOAD +;;; code might reasonably use READ-LINE to get the value to compare +;;; against. +(defparameter *fasl-header-string-start-string* "# FASL") + +;;; the code for a character which terminates a fasl file header +(defconstant +fasl-header-string-stop-char-code+ 255) + +;;; This value should be incremented when the system changes in such +;;; a way that it will no longer work reliably with old fasl files. - (defconstant +fasl-file-version+ 13) ++(defconstant +fasl-file-version+ 14) +;;; 2 = sbcl-0.6.4 uses COMPILE-OR-LOAD-DEFGENERIC. +;;; 3 = sbcl-0.6.6 uses private symbol, not :EMPTY, for empty HASH-TABLE slot. +;;; 4 = sbcl-0.6.7 uses HAIRY-DATA-VECTOR-REF and HAIRY-DATA-VECTOR-SET +;;; when array headers or data element type uncertainty exist, and +;;; uses DATA-VECTOR-REF and DATA-VECTOR-SET only for VOPs. (Thus, +;;; full calls to DATA-VECTOR-REF and DATA-VECTOR-SET from older +;;; fasl files would fail, because there are no DEFUNs for these +;;; operations any more.) +;;; 5 = sbcl-0.6.8 has rearranged static symbols. +;;; 6 = sbcl-0.6.9, got rid of non-ANSI %DEFCONSTANT/%%DEFCONSTANT stuff +;;; and deleted a slot from DEBUG-SOURCE structure. +;;; 7 = around sbcl-0.6.9.8, merged SB-CONDITIONS package into SB-KERNEL +;;; 8 = sbcl-0.6.10.4 revived Gray stream support, changing stream layouts. +;;; 9 = deleted obsolete CONS-UNIQUE-TAG bytecode in sbcl-0.6.11.8 +;;; (somewhere in here also changes to AND and OR CTYPE layouts) +;;; 10 = new layout for CONDITION in sbcl-0.6.11.38 +;;; 11 = (a) new helper functions for MAKE-LOAD-FORM (HASH-TABLE) in +;;; sbcl-0.6.12.11 +;;; (b) new address space constants for OpenBSD in 0.6.12.17 +;;; (doesn't need separate version from (a) because the +;;; OpenBSD port was broken from sometime before 0.6.12.11 +;;; until the address space was changed) +;;; 12 = sbcl-0.6.12.22 added new SB-FASL package - ;;; 13 = sbcl-0.6.12.x removed some elements from *STATIC-SYMBOLS* ++;;; 13 = sbcl-0.6.12.28 removed some elements from *STATIC-SYMBOLS* ++;;; 14 = sbcl-0.6.12.29 removed more elements from *STATIC-SYMBOLS* + +;;; the conventional file extension for fasl files on this +;;; architecture, e.g. "x86f" +(declaim (type (or simple-string null) *backend-fasl-file-type*)) +(defvar *backend-fasl-file-type* nil) + +;;; This is a sort of pun that we inherited from CMU CL. For ordinary, +;;; non-byte-coded fasl files, the "implementation" is basically the +;;; CPU. For byte-coded fasl files, the "implementation" is whether +;;; the data are stored big-endianly or little-endianly. +(defun backend-byte-fasl-file-implementation () + *backend-byte-order*) + +;;; information about below-Lisp-level linkage +;;; +;;; Note: +;;; Assembler routines are named by full Lisp symbols: they +;;; have packages and that sort of native Lisp stuff associated +;;; with them. We can compare them with EQ. +;;; Foreign symbols are named by Lisp strings: the Lisp package +;;; system doesn't extend out to symbols in languages like C. +;;; We want to use EQUAL to compare them. +;;; *STATIC-FOREIGN-SYMBOLS* are static as opposed to "dynamic" (not +;;; as opposed to "extern"). The table contains symbols known at +;;; the time that the program was built, but not symbols defined +;;; in object files which have been loaded dynamically since then. +(declaim (type hash-table *assembler-routines* *static-foreign-symbols*)) +(defvar *assembler-routines* (make-hash-table :test 'eq)) +(defvar *static-foreign-symbols* (make-hash-table :test 'equal)) + +;;;; the FOP database + +(declaim (simple-vector *fop-names* *fop-functions*)) + +;;; a vector indexed by a FaslOP that yields the FOP's name +(defvar *fop-names* (make-array 256 :initial-element nil)) + +;;; a vector indexed by a FaslOP that yields a function of 0 arguments +;;; which will perform the operation +(defvar *fop-functions* + (make-array 256 + :initial-element (lambda () + (error "corrupt fasl file: losing FOP")))) + +;;;; other miscellaneous loading-related stuff + + +;;;; variables + +(defvar *load-depth* 0 + #!+sb-doc + "the current number of recursive LOADs") +(declaim (type index *load-depth*)) + +;;; the FASL file we're reading from +(defvar *fasl-input-stream*) +(declaim (type lisp-stream *fasl-input-stream*)) + +(defvar *load-print* nil + #!+sb-doc + "the default for the :PRINT argument to LOAD") +(defvar *load-verbose* nil + ;; Note that CMU CL's default for this was T, and ANSI says it's + ;; implementation-dependent. We choose NIL on the theory that it's + ;; a nicer default behavior for Unix programs. + #!+sb-doc + "the default for the :VERBOSE argument to LOAD") + +(defvar *load-code-verbose* nil) + diff --cc src/compiler/alpha/parms.lisp index 55511ad,c618478..710f789 --- a/src/compiler/alpha/parms.lisp +++ b/src/compiler/alpha/parms.lisp @@@ -173,7 -174,7 +173,6 @@@ sb!kernel::internal-error sb!di::handle-breakpoint sb!di::handle-function-end-breakpoint - fdefinition-object - sb!impl::fdefinition-object ;; free Pointers *read-only-space-free-pointer* diff --cc src/compiler/generic/genesis.lisp index 55c58b2,c50f246..1e4c5dc --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@@ -1137,18 -1133,18 +1137,16 @@@ ;; the function values for these things?? I.e. why do we need this ;; section at all? Is it because all the FDEFINITION stuff gets in ;; the way of reading function values and is too hairy to rely on at -- ;; cold boot? FIXME: 5/6 of these are in *STATIC-SYMBOLS* in ++ ;; cold boot? FIXME: Most of these are in *STATIC-SYMBOLS* in ;; parms.lisp, but %HANDLE-FUNCTION-END-BREAKPOINT is not. Why? ;; Explain. (macrolet ((frob (symbol) `(cold-set ',symbol (cold-fdefinition-object (cold-intern ',symbol))))) -- (frob !cold-init) - (frob sb!impl::maybe-gc) + (frob maybe-gc) (frob internal-error) (frob sb!di::handle-breakpoint) -- (frob sb!di::handle-function-end-breakpoint) - (frob fdefinition-object)) - (frob sb!impl::fdefinition-object)) ++ (frob sb!di::handle-function-end-breakpoint)) (cold-set '*current-catch-block* (make-fixnum-descriptor 0)) (cold-set '*current-unwind-protect-block* (make-fixnum-descriptor 0)) diff --cc src/compiler/x86/parms.lisp index b95bc6f,8bbe40c..81718ef --- a/src/compiler/x86/parms.lisp +++ b/src/compiler/x86/parms.lisp @@@ -236,11 -238,11 +236,10 @@@ sb!impl::*!initial-fdefn-objects* ;; functions that the C code needs to call -- sb!impl::!cold-init - sb!impl::maybe-gc + maybe-gc sb!kernel::internal-error sb!di::handle-breakpoint - sb!impl::fdefinition-object + fdefinition-object ;; free pointers ;; diff --cc version.lisp-expr index 770f79e,dd677f1..c233468 --- a/version.lisp-expr +++ b/version.lisp-expr @@@ -15,4 -15,4 +15,4 @@@ ;;; versions, and a string like "0.6.5.12" is used for versions which ;;; aren't released but correspond only to CVS tags or snapshots. - "0.6.12.28" -"0.6.12.21.flaky2.2" ++"0.6.12.29"