1 ;;;; This file contains portable versions of low-level functions and macros
2 ;;;; which are ripe for implementation specific customization. None of the code
3 ;;;; in this file *has* to be customized for a particular Common Lisp
4 ;;;; implementation. Moreover, in some implementations it may not make any
5 ;;;; sense to customize some of this code.
7 ;;;; The original version was intended to support portable customization to
8 ;;;; lotso different Lisp implementations. This functionality is gone in the
9 ;;;; current version, and it now runs only under SBCL. (Now that ANSI Common
10 ;;;; Lisp has mixed CLOS into the insides of the system (e.g. error handling
11 ;;;; and printing) so deeply that it's not very meaningful to bootstrap Common
12 ;;;; Lisp without CLOS, the old functionality is of dubious use. -- WHN
15 ;;;; This software is part of the SBCL system. See the README file for more
18 ;;;; This software is derived from software originally released by Xerox
19 ;;;; Corporation. Copyright and release statements follow. Later modifications
20 ;;;; to the software are in the public domain and are provided with
21 ;;;; absolutely no warranty. See the COPYING and CREDITS files for more
24 ;;;; copyright information from original PCL sources:
26 ;;;; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation.
27 ;;;; All rights reserved.
29 ;;;; Use and copying of this software and preparation of derivative works based
30 ;;;; upon this software are permitted. Any distribution of this software or
31 ;;;; derivative works must comply with all applicable United States export
34 ;;;; This software is made available AS IS, and Xerox Corporation makes no
35 ;;;; warranty about the software, its performance or its conformity to any
40 (eval-when (:compile-toplevel :load-toplevel :execute)
41 (defvar *optimize-speed*
42 '(optimize (speed 3) (safety 0)))
45 (defmacro dotimes-fixnum ((var count &optional (result nil)) &body body)
46 `(dotimes (,var (the fixnum ,count) ,result)
47 (declare (fixnum ,var))
50 ;;;; early definition of WRAPPER
52 ;;;; Most WRAPPER stuff is defined later, but the DEFSTRUCT itself
53 ;;;; is here early so that things like (TYPEP .. 'WRAPPER) can be
54 ;;;; compiled efficiently.
56 ;;; Note that for SBCL, as for CMU CL, the WRAPPER of a built-in or
57 ;;; structure class will be some other kind of SB-KERNEL:LAYOUT, but
58 ;;; this shouldn't matter, since the only two slots that WRAPPER adds
59 ;;; are meaningless in those cases.
61 (:include sb-kernel:layout
62 ;; KLUDGE: In CMU CL, the initialization default
63 ;; for LAYOUT-INVALID was NIL. In SBCL, that has
64 ;; changed to :UNINITIALIZED, but PCL code might
65 ;; still expect NIL for the initialization
66 ;; default of WRAPPER-INVALID. Instead of trying
67 ;; to find out, I just overrode the LAYOUT
68 ;; default here. -- WHN 19991204
70 (:conc-name %wrapper-)
71 (:constructor make-wrapper-internal)
73 (instance-slots-layout nil :type list)
74 (class-slots nil :type list))
75 #-sb-fluid (declaim (sb-ext:freeze-type wrapper))
77 ;;;; PCL's view of funcallable instances
79 (sb-kernel:!defstruct-with-alternate-metaclass pcl-funcallable-instance
80 ;; KLUDGE: Note that neither of these slots is ever accessed by its
81 ;; accessor name as of sbcl-0.pre7.63. Presumably everything works
82 ;; by puns based on absolute locations. Fun fun fun.. -- WHN 2001-10-30
83 :slot-names (clos-slots name)
84 :boa-constructor %make-pcl-funcallable-instance
85 :superclass-name sb-kernel:funcallable-instance
86 :metaclass-name sb-kernel:random-pcl-class
87 :metaclass-constructor sb-kernel:make-random-pcl-class
88 :dd-type sb-kernel:funcallable-structure
89 ;; Only internal implementation code will access these, and these
90 ;; accesses (slot readers in particular) could easily be a
91 ;; bottleneck, so it seems reasonable to suppress runtime type
94 ;; (Except note KLUDGE above that these accessors aren't used at all
95 ;; (!) as of sbcl-0.pre7.63, so for now it's academic.)
96 :runtime-type-checks-p nil)
98 (import 'sb-kernel:funcallable-instance-p)
100 (defun set-funcallable-instance-fun (fin new-value)
101 (declare (type function new-value))
102 (aver (funcallable-instance-p fin))
103 (setf (sb-kernel:funcallable-instance-fun fin) new-value))
104 (defmacro fsc-instance-p (fin)
105 `(funcallable-instance-p ,fin))
106 (defmacro fsc-instance-wrapper (fin)
107 `(sb-kernel:%funcallable-instance-layout ,fin))
108 (defmacro fsc-instance-slots (fin)
109 `(sb-kernel:%funcallable-instance-info ,fin 0))
111 (declaim (inline clos-slots-ref (setf clos-slots-ref)))
112 (declaim (ftype (function (simple-vector index) t) clos-slots-ref))
113 (defun clos-slots-ref (slots index)
115 (declaim (ftype (function (t simple-vector index) t) (setf clos-slots-ref)))
116 (defun (setf clos-slots-ref) (new-value slots index)
117 (setf (svref slots index) new-value))
119 ;;; Note on implementation under CMU CL >=17 and SBCL: STD-INSTANCE-P
120 ;;; is only used to discriminate between functions (including FINs)
121 ;;; and normal instances, so we can return true on structures also. A
122 ;;; few uses of (OR STD-INSTANCE-P FSC-INSTANCE-P) are changed to
124 (defmacro std-instance-p (x)
125 `(sb-kernel:%instancep ,x))
127 ;; a temporary definition used for debugging the bootstrap
129 (defun print-std-instance (instance stream depth)
130 (declare (ignore depth))
131 (print-unreadable-object (instance stream :type t :identity t)
132 (let ((class (class-of instance)))
133 (when (or (eq class (find-class 'standard-class nil))
134 (eq class (find-class 'funcallable-standard-class nil))
135 (eq class (find-class 'built-in-class nil)))
136 (princ (early-class-name instance) stream)))))
138 ;;; This is the value that we stick into a slot to tell us that it is
139 ;;; unbound. It may seem gross, but for performance reasons, we make
140 ;;; this an interned symbol. That means that the fast check to see
141 ;;; whether a slot is unbound is to say (EQ <val> '..SLOT-UNBOUND..).
142 ;;; That is considerably faster than looking at the value of a special
143 ;;; variable. Be careful, there are places in the code which actually
144 ;;; use ..SLOT-UNBOUND.. rather than this variable. So much for
147 ;;; FIXME: Now that we're tightly integrated into SBCL, we could use
148 ;;; the SBCL built-in unbound value token instead. Perhaps if we did
149 ;;; so it would be a good idea to define collections of CLOS slots as
150 ;;; a new type of heap object, instead of using bare SIMPLE-VECTOR, in
151 ;;; order to avoid problems (in the debugger if nowhere else) with
152 ;;; SIMPLE-VECTORs some of whose elements are unbound tokens.
153 (defconstant +slot-unbound+ '..slot-unbound..)
155 (defmacro %allocate-static-slot-storage--class (no-of-slots)
156 `(make-array ,no-of-slots :initial-element +slot-unbound+))
158 (defmacro std-instance-class (instance)
159 `(wrapper-class* (std-instance-wrapper ,instance)))
161 ;;; When given a function should give this function the name
162 ;;; NEW-NAME. Note that NEW-NAME is sometimes a list. Some lisps
163 ;;; get the upset in the tummy when they start thinking about
164 ;;; functions which have lists as names. To deal with that there is
165 ;;; SET-FUN-NAME-INTERN which takes a list spec for a function
166 ;;; name and turns it into a symbol if need be.
168 ;;; When given a funcallable instance, SET-FUN-NAME *must* side-effect
169 ;;; that FIN to give it the name. When given any other kind of
170 ;;; function SET-FUN-NAME is allowed to return a new function which is
171 ;;; "the same" except that it has the name.
173 ;;; In all cases, SET-FUN-NAME must return the new (or same)
174 ;;; function. (Unlike other functions to set stuff, it does not return
176 (defun set-fun-name (fcn new-name)
178 "Set the name of a compiled function object. Return the function."
179 (declare (special *boot-state* *the-class-standard-generic-function*))
181 (set-fun-name (symbol-function fcn) new-name))
182 ((funcallable-instance-p fcn)
183 (if (if (eq *boot-state* 'complete)
184 (typep fcn 'generic-function)
185 (eq (class-of fcn) *the-class-standard-generic-function*))
186 (setf (sb-kernel:%funcallable-instance-info fcn 1) new-name)
187 (bug "unanticipated function type"))
190 ;; pw-- This seems wrong and causes trouble. Tests show
191 ;; that loading CL-HTTP resulted in ~5400 closures being
192 ;; passed through this code of which ~4000 of them pointed
193 ;; to but 16 closure-functions, including 1015 each of
194 ;; DEFUN MAKE-OPTIMIZED-STD-WRITER-METHOD-FUNCTION
195 ;; DEFUN MAKE-OPTIMIZED-STD-READER-METHOD-FUNCTION
196 ;; DEFUN MAKE-OPTIMIZED-STD-BOUNDP-METHOD-FUNCTION.
197 ;; Since the actual functions have been moved by PURIFY
198 ;; to memory not seen by GC, changing a pointer there
199 ;; not only clobbers the last change but leaves a dangling
200 ;; pointer invalid after the next GC. Comments in low.lisp
201 ;; indicate this code need do nothing. Setting the
202 ;; function-name to NIL loses some info, and not changing
203 ;; it loses some info of potential hacking value. So,
204 ;; lets not do this...
206 (let ((header (sb-kernel:%closure-fun fcn)))
207 (setf (sb-kernel:%simple-fun-name header) new-name))
209 ;; XXX Maybe add better scheme here someday.
212 (defun intern-fun-name (name)
213 (cond ((symbolp name) name)
215 (intern (let ((*package* *pcl-package*)
216 (*print-case* :upcase)
219 (format nil "~S" name))
222 ;;; FIXME: probably no longer needed after init
223 (defmacro precompile-random-code-segments (&optional system)
225 (eval-when (:compile-toplevel)
226 (update-dispatch-dfuns)
227 (compile-iis-functions nil))
228 (precompile-function-generators ,system)
229 (precompile-dfun-constructors ,system)
230 (precompile-iis-functions ,system)
231 (eval-when (:load-toplevel)
232 (compile-iis-functions t))))
234 ;;; This definition is for interpreted code.
235 (defun pcl-instance-p (x)
236 (typep (sb-kernel:layout-of x) 'wrapper))
239 ;;; We define this as STANDARD-INSTANCE, since we're going to
240 ;;; clobber the layout with some standard-instance layout as soon as
241 ;;; we make it, and we want the accessor to still be type-correct.
243 (defstruct (standard-instance
245 (:constructor %%allocate-instance--class ())
247 (:alternate-metaclass sb-kernel:instance
249 sb-kernel:make-standard-class))
252 (sb-kernel:!defstruct-with-alternate-metaclass standard-instance
254 :boa-constructor %make-standard-instance
255 :superclass-name sb-kernel:instance
256 :metaclass-name cl:standard-class
257 :metaclass-constructor sb-kernel:make-standard-class
259 :runtime-type-checks-p nil)
261 ;;; Both of these operations "work" on structures, which allows the above
262 ;;; weakening of STD-INSTANCE-P.
263 (defmacro std-instance-slots (x) `(sb-kernel:%instance-ref ,x 1))
264 (defmacro std-instance-wrapper (x) `(sb-kernel:%instance-layout ,x))
266 ;;; FIXME: These functions are called every place we do a
267 ;;; CALL-NEXT-METHOD, and probably other places too. It's likely worth
268 ;;; selectively optimizing them with DEFTRANSFORMs and stuff, rather
269 ;;; than just indiscriminately expanding them inline everywhere.
270 (declaim (inline get-slots get-slots-or-nil))
271 (declaim (ftype (function (t) simple-vector) get-slots))
272 (declaim (ftype (function (t) (or simple-vector null)) get-slots-or-nil))
273 (defun get-slots (instance)
274 (if (std-instance-p instance)
275 (std-instance-slots instance)
276 (fsc-instance-slots instance)))
277 (defun get-slots-or-nil (instance)
278 (when (pcl-instance-p instance)
279 (get-slots instance)))
281 (defmacro built-in-or-structure-wrapper (x) `(sb-kernel:layout-of ,x))
283 (defmacro get-wrapper (inst)
284 (once-only ((wrapper `(wrapper-of ,inst)))
286 (aver (typep ,wrapper 'wrapper))
289 ;;; FIXME: could be an inline function or ordinary function (like many
290 ;;; other things around here)
291 (defmacro get-instance-wrapper-or-nil (inst)
292 (once-only ((wrapper `(wrapper-of ,inst)))
293 `(if (typep ,wrapper 'wrapper)
297 ;;;; structure-instance stuff
299 ;;;; FIXME: Now that the code is SBCL-only, this extra layer of
300 ;;;; abstraction around our native structure representation doesn't
301 ;;;; seem to add anything useful, and could probably go away.
303 ;;; The definition of STRUCTURE-TYPE-P was moved to early-low.lisp.
305 (defun get-structure-dd (type)
306 (sb-kernel:layout-info (sb-kernel:class-layout (cl:find-class type))))
308 (defun structure-type-included-type-name (type)
309 (let ((include (sb-kernel::dd-include (get-structure-dd type))))
314 (defun structure-type-slot-description-list (type)
315 (nthcdr (length (let ((include (structure-type-included-type-name type)))
317 (sb-kernel:dd-slots (get-structure-dd include)))))
318 (sb-kernel:dd-slots (get-structure-dd type))))
320 (defun structure-slotd-name (slotd)
321 (sb-kernel:dsd-name slotd))
323 (defun structure-slotd-accessor-symbol (slotd)
324 (sb-kernel:dsd-accessor-name slotd))
326 (defun structure-slotd-reader-function (slotd)
327 (fdefinition (sb-kernel:dsd-accessor-name slotd)))
329 (defun structure-slotd-writer-function (slotd)
330 (unless (sb-kernel:dsd-read-only slotd)
331 (fdefinition `(setf ,(sb-kernel:dsd-accessor-name slotd)))))
333 (defun structure-slotd-type (slotd)
334 (sb-kernel:dsd-type slotd))
336 (defun structure-slotd-init-form (slotd)
337 (sb-kernel::dsd-default slotd))