From: William Harold Newman Date: Wed, 6 Jun 2001 21:45:48 +0000 (+0000) Subject: (no version): X-Git-Url: http://repo.macrolet.net/gitweb/?a=commitdiff_plain;h=148cf41d8ad17dba56509b0c901cfd1b211dbc1d;p=sbcl.git (no version): updating/committing again to get CVS to recognize deletion of early-load and addition of early-fasl --- diff --git a/src/code/early-fasl.lisp b/src/code/early-fasl.lisp new file mode 100644 index 0000000..b5c7849 --- /dev/null +++ b/src/code/early-fasl.lisp @@ -0,0 +1,134 @@ +;;;; 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+ 12) +;;; 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 + +;;; 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 --git a/src/code/early-load.lisp b/src/code/early-load.lisp deleted file mode 100644 index b3aa472..0000000 --- a/src/code/early-load.lisp +++ /dev/null @@ -1,75 +0,0 @@ -;;;; needed-early stuff for the loader - -;;;; 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!IMPL") - -;;; information about non-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 -(defvar *fop-names* (make-array 256 :initial-element nil) - #!+sb-doc - "a vector indexed by a FaslOP that yields the FOP's name") -(defvar *fop-functions* - (make-array 256 - :initial-element (lambda () - (error "corrupt fasl file: losing FOP"))) - #!+sb-doc - "a vector indexed by a FaslOP that yields a function of 0 arguments which - will perform the operation") -(declaim (simple-vector *fop-names* *fop-functions*)) - -(defvar *load-code-verbose* nil) - -;;; Moving native code during a GC or purify is not trivial on the x86 -;;; port, so there are a few options for code placement. -;;; -;;; Byte-compiled code objects can always be moved so can be place in -;;; the dynamics heap. This is enabled with -;;; *load-byte-compiled-code-to-dynamic-space*. -;;; FIXME: See whether this really works. Also, now that we have gencgc -;;; and all code moves, perhaps we could just remove this conditional -;;; and make this fixed behavior. -;;; -;;; Native code top level forms only have a short life so can be -;;; safely loaded into the dynamic heap (without fixups) so long as -;;; the GC is not active. This could be handy during a world load to -;;; save core space without the need to enable the support for moving -;;; x86 native code. Enable with *load-x86-tlf-to-dynamic-space*. -;;; FIXME: Yikes! Could we punt this? -;;; -;;; One strategy for allowing the loading of x86 native code into the -;;; dynamic heap requires that the addresses of fixups be saved for -;;; all these code objects. After a purify these fixups can be -;;; dropped. This is enabled with *enable-dynamic-space-code*. -;;; -;;; A little analysis of the header information is used to determine -;;; if a code object is byte compiled, or native code. -(defvar *load-byte-compiled-code-to-dynamic-space* t) -(defvar *load-x86-tlf-to-dynamic-space* nil) ; potentially dangerous with CGC. - ; KLUDGE: Yikes squared! -(defvar *enable-dynamic-space-code* #!-gencgc nil #!+gencgc t) -;;; FIXME: I think all of these should go away. I can't see a good reason -;;; not to just make everything relocatable.