(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
-;;; a magic number used to identify core files
+;;; a magic number used to identify our core files
(defconstant core-magic
(logior (ash (char-code #\S) 24)
(ash (char-code #\B) 16)
;;; IP packets), and in fact the CMU CL version number never ended up
;;; being incremented past 0. A better approach might be to use a
;;; string which is set from CVS data.
-(defconstant sbcl-core-version-integer 0)
+;;;
+;;; 0: inherited from CMU CL
+;;; 1: rearranged static symbols for sbcl-0.6.8
+(defconstant sbcl-core-version-integer 1)
(defun round-up (number size)
#!+sb-doc
(defun write-c-header ()
+ ;; writing beginning boilerplate
(format t "/*~%")
(dolist (line
'("This is a machine-generated file. Do not edit it by hand."
(format t " * ~A~%" line))
(format t " */~%")
(terpri)
-
(format t "#ifndef _SBCL_H_~%#define _SBCL_H_~%")
(terpri)
+ ;; writing miscellaneous constants
(format t "#define SBCL_CORE_VERSION_INTEGER ~D~%" sbcl-core-version-integer)
(format t
"#define SBCL_VERSION_STRING ~S~%"
(sb!xc:lisp-implementation-version))
(format t "#define CORE_MAGIC 0x~X~%" core-magic)
(terpri)
-
;; FIXME: Other things from core.h should be defined here too:
;; #define CORE_END 3840
;; #define CORE_NDIRECTORY 3861
;; #define STATIC_SPACE_ID (2)
;; #define READ_ONLY_SPACE_ID (3)
+ ;; writing entire families of named constants from SB!VM
(let ((constants nil))
(do-external-symbols (symbol (find-package "SB!VM"))
(when (constantp symbol)
(let ((name (symbol-name symbol)))
- (labels
- ((record (prefix string priority)
- (push (list (concatenate
- 'simple-string
- prefix
- (delete #\- (string-capitalize string)))
- priority
- (symbol-value symbol)
- (fdocumentation symbol 'variable))
- constants))
- (test-tail (tail prefix priority)
- (when (tail-comp name tail)
- (record prefix
- (subseq name 0
- (- (length name)
- (length tail)))
- priority)))
- (test-head (head prefix priority)
- (when (head-comp name head)
- (record prefix
- (subseq name (length head))
- priority))))
+ (labels (;; shared machinery
+ (record (string priority)
+ (push (list string
+ priority
+ (symbol-value symbol)
+ (documentation symbol 'variable))
+ constants))
+ ;; machinery for old-style CMU CL Lisp-to-C naming
+ (record-with-munged-name (prefix string priority)
+ (record (concatenate
+ 'simple-string
+ prefix
+ (delete #\- (string-capitalize string)))
+ priority))
+ (test-tail (tail prefix priority)
+ (when (tail-comp name tail)
+ (record-with-munged-name prefix
+ (subseq name 0
+ (- (length name)
+ (length tail)))
+ priority)))
+ (test-head (head prefix priority)
+ (when (head-comp name head)
+ (record-with-munged-name prefix
+ (subseq name (length head))
+ priority)))
+ ;; machinery for new-style SBCL Lisp-to-C naming
+ (record-with-translated-name (priority)
+ (record (substitute #\_ #\- name)
+ priority)))
+ ;; This style of munging of names is used in the code
+ ;; inherited from CMU CL.
(test-tail "-TYPE" "type_" 0)
(test-tail "-FLAG" "flag_" 1)
(test-tail "-TRAP" "trap_" 2)
(test-tail "-SUBTYPE" "subtype_" 3)
(test-head "TRACE-TABLE-" "tracetab_" 4)
- (test-tail "-SC-NUMBER" "sc_" 5)))))
+ (test-tail "-SC-NUMBER" "sc_" 5)
+ ;; This simpler style of translation of names seems less
+ ;; confusing, and is used for newer code.
+ (when (some (lambda (suffix) (tail-comp name suffix))
+ #("-START" "-END"))
+ (record-with-translated-name 6))))))
(setf constants
(sort constants
#'(lambda (const1 const2)
(< (second const1) (second const2))))))
(let ((prev-priority (second (car constants))))
(dolist (const constants)
- (unless (= prev-priority (second const))
- (terpri)
- (setf prev-priority (second const)))
- (format t
- "#define ~A ~D /* 0x~X */~@[ /* ~A */~]~%"
- (first const)
- (third const)
- (third const)
- (fourth const))))
- (terpri)
- (format t "#define ERRORS { \\~%")
- ;; FIXME: Is this just DO-VECTOR?
- (let ((internal-errors sb!c:*backend-internal-errors*))
- (dotimes (i (length internal-errors))
- (format t " ~S, /*~D*/ \\~%" (cdr (aref internal-errors i)) i)))
- (format t " NULL \\~%}~%")
+ (destructuring-bind (name priority value doc) const
+ (unless (= prev-priority priority)
+ (terpri)
+ (setf prev-priority priority))
+ (format t "#define ~A " name)
+ (format t
+ ;; KLUDGE: As of sbcl-0.6.7.14, we're dumping two
+ ;; different kinds of values here, (1) small codes
+ ;; and (2) machine addresses. The small codes can be
+ ;; dumped as bare integer values. The large machine
+ ;; addresses might cause problems if they're large
+ ;; and represented as (signed) C integers, so we
+ ;; want to force them to be unsigned. We do that by
+ ;; wrapping them in the LISPOBJ macro. (We could do
+ ;; it with a bare "(unsigned)" cast, except that
+ ;; this header file is used not only in C files, but
+ ;; also in assembly files, which don't understand
+ ;; the cast syntax. The LISPOBJ macro goes away in
+ ;; assembly files, but that shouldn't matter because
+ ;; we don't do arithmetic on address constants in
+ ;; assembly files. See? It really is a kludge..) --
+ ;; WHN 2000-10-18
+ (let (;; cutoff for treatment as a small code
+ (cutoff (expt 2 16)))
+ (cond ((minusp value)
+ (error "stub: negative values unsupported"))
+ ((< value cutoff)
+ "~D")
+ (t
+ "LISPOBJ(~D)")))
+ value)
+ (format t " /* 0x~X */~@[ /* ~A */~]~%" value doc))))
(terpri))
+
+ ;; writing codes/strings for internal errors
+ (format t "#define ERRORS { \\~%")
+ ;; FIXME: Is this just DO-VECTOR?
+ (let ((internal-errors sb!c:*backend-internal-errors*))
+ (dotimes (i (length internal-errors))
+ (format t " ~S, /*~D*/ \\~%" (cdr (aref internal-errors i)) i)))
+ (format t " NULL \\~%}~%")
+ (terpri)
+
+ ;; writing primitive object layouts
(let ((structs (sort (copy-list sb!vm:*primitive-objects*) #'string<
:key #'(lambda (obj)
(symbol-name
(- (* (sb!vm:slot-offset slot) sb!vm:word-bytes) lowtag)))
(terpri))))
(format t "#endif /* LANGUAGE_ASSEMBLY */~2%"))
+
+ ;; writing static symbol offsets
(dolist (symbol (cons nil sb!vm:*static-symbols*))
;; FIXME: It would be nice to use longer names NIL and (particularly) T
;; in #define statements.
sb!vm:word-bytes
sb!vm:other-pointer-type
(if symbol (sb!vm:static-symbol-offset symbol) 0)))))
+
+ ;; Voila.
(format t "~%#endif~%"))
\f
;;;; writing map file
(*cold-package-symbols* nil)
(*read-only* (make-gspace :read-only
read-only-space-id
- sb!vm:*read-only-space-start*))
+ sb!vm:read-only-space-start))
(*static* (make-gspace :static
static-space-id
sb!vm:static-space-start))
(*dynamic* (make-gspace :dynamic
dynamic-space-id
- sb!vm:*dynamic-space-start*))
+ sb!vm:dynamic-space-start))
(*nil-descriptor* (make-nil-descriptor))
(*current-reversed-cold-toplevels* *nil-descriptor*)
(*unbound-marker* (make-other-immediate-descriptor
projects / sbcl.git / blobdiff