0.9.1.7: "fix" SB-SPROF on non-gencgc platforms
[sbcl.git] / src / pcl / low.lisp
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.
6 ;;;;
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
13 ;;;; 19981108)
14
15 ;;;; This software is part of the SBCL system. See the README file for more
16 ;;;; information.
17
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
22 ;;;; information.
23
24 ;;;; copyright information from original PCL sources:
25 ;;;;
26 ;;;; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990 Xerox Corporation.
27 ;;;; All rights reserved.
28 ;;;;
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
32 ;;;; control laws.
33 ;;;;
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
36 ;;;; specification.
37
38 (in-package "SB-PCL")
39 \f
40 (eval-when (:compile-toplevel :load-toplevel :execute)
41 (defvar *optimize-speed*
42   '(optimize (speed 3) (safety 0)))
43 ) ; EVAL-WHEN
44
45 (defmacro dotimes-fixnum ((var count &optional (result nil)) &body body)
46   `(dotimes (,var (the fixnum ,count) ,result)
47      (declare (fixnum ,var))
48      ,@body))
49 \f
50 ;;;; early definition of WRAPPER
51 ;;;;
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.
55
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.
60 (defstruct (wrapper
61             (:include 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
69                       (invalid nil))
70             (:conc-name %wrapper-)
71             (:constructor make-wrapper-internal)
72             (:copier nil))
73   (instance-slots-layout nil :type list)
74   (class-slots nil :type list))
75 #-sb-fluid (declaim (sb-ext:freeze-type wrapper))
76 \f
77 ;;;; PCL's view of funcallable instances
78
79 (!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 hash-code)
84   :boa-constructor %make-pcl-funcallable-instance
85   :superclass-name funcallable-instance
86   :metaclass-name random-pcl-classoid
87   :metaclass-constructor make-random-pcl-classoid
88   :dd-type 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
92   ;; checks.
93   ;;
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)
97
98 (import 'sb-kernel:funcallable-instance-p)
99
100 (defun set-funcallable-instance-function (fin new-value)
101   (declare (type function new-value))
102   (aver (funcallable-instance-p fin))
103   (setf (funcallable-instance-fun fin) new-value))
104 (defmacro fsc-instance-p (fin)
105   `(funcallable-instance-p ,fin))
106 (defmacro fsc-instance-wrapper (fin)
107   `(%funcallable-instance-layout ,fin))
108 ;;; FIXME: This seems to bear no relation at all to the CLOS-SLOTS
109 ;;; slot in the FUNCALLABLE-INSTANCE structure, above, which
110 ;;; (bizarrely) seems to be set to the NAME of the
111 ;;; FUNCALLABLE-INSTANCE. At least, the index 1 seems to return the
112 ;;; NAME, and the index 2 NIL.  Weird.  -- CSR, 2002-11-07
113 (defmacro fsc-instance-slots (fin)
114   `(%funcallable-instance-info ,fin 0))
115 (defmacro fsc-instance-hash (fin)
116   `(%funcallable-instance-info ,fin 3))
117 \f
118 (declaim (inline clos-slots-ref (setf clos-slots-ref)))
119 (declaim (ftype (function (simple-vector index) t) clos-slots-ref))
120 (defun clos-slots-ref (slots index)
121   (svref slots index))
122 (declaim (ftype (function (t simple-vector index) t) (setf clos-slots-ref)))
123 (defun (setf clos-slots-ref) (new-value slots index)
124   (setf (svref slots index) new-value))
125
126 ;;; Note on implementation under CMU CL >=17 and SBCL: STD-INSTANCE-P
127 ;;; is only used to discriminate between functions (including FINs)
128 ;;; and normal instances, so we can return true on structures also. A
129 ;;; few uses of (OR STD-INSTANCE-P FSC-INSTANCE-P) are changed to
130 ;;; PCL-INSTANCE-P.
131 (defmacro std-instance-p (x)
132   `(%instancep ,x))
133
134 ;; a temporary definition used for debugging the bootstrap
135 #+sb-show
136 (defun print-std-instance (instance stream depth)
137   (declare (ignore depth))      
138   (print-unreadable-object (instance stream :type t :identity t)
139     (let ((class (class-of instance)))
140       (when (or (eq class (find-class 'standard-class nil))
141                 (eq class (find-class 'funcallable-standard-class nil))
142                 (eq class (find-class 'built-in-class nil)))
143         (princ (early-class-name instance) stream)))))
144
145 ;;; This is the value that we stick into a slot to tell us that it is
146 ;;; unbound. It may seem gross, but for performance reasons, we make
147 ;;; this an interned symbol. That means that the fast check to see
148 ;;; whether a slot is unbound is to say (EQ <val> '..SLOT-UNBOUND..).
149 ;;; That is considerably faster than looking at the value of a special
150 ;;; variable. Be careful, there are places in the code which actually
151 ;;; use ..SLOT-UNBOUND.. rather than this variable. So much for
152 ;;; modularity..
153 ;;;
154 ;;; FIXME: Now that we're tightly integrated into SBCL, we could use
155 ;;; the SBCL built-in unbound value token instead. Perhaps if we did
156 ;;; so it would be a good idea to define collections of CLOS slots as
157 ;;; a new type of heap object, instead of using bare SIMPLE-VECTOR, in
158 ;;; order to avoid problems (in the debugger if nowhere else) with
159 ;;; SIMPLE-VECTORs some of whose elements are unbound tokens.
160 (defconstant +slot-unbound+ '..slot-unbound..)
161
162 (defmacro %allocate-static-slot-storage--class (no-of-slots)
163   `(make-array ,no-of-slots :initial-element +slot-unbound+))
164
165 (defmacro std-instance-class (instance)
166   `(wrapper-class* (std-instance-wrapper ,instance)))
167 \f
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.
172 ;;;
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
175 ;;; the new value.)
176 (defun set-fun-name (fun new-name)
177   #+sb-doc
178   "Set the name of a compiled function object. Return the function."
179   (declare (special *boot-state* *the-class-standard-generic-function*))
180   (when (valid-function-name-p fun)
181     (setq fun (fdefinition fun)))
182   (when (funcallable-instance-p fun)
183     (if (if (eq *boot-state* 'complete)
184                  (typep fun 'generic-function)
185                  (eq (class-of fun) *the-class-standard-generic-function*))
186              (setf (%funcallable-instance-info fun 1) new-name)
187              (bug "unanticipated function type")))
188   ;; Fixup name-to-function mappings in cases where the function
189   ;; hasn't been defined by DEFUN.  (FIXME: is this right?  This logic
190   ;; comes from CMUCL).  -- CSR, 2004-12-31
191   (when (and (consp new-name)
192              (member (car new-name) '(slow-method fast-method slot-accessor)))
193     (setf (fdefinition new-name) fun))
194   fun)
195 \f
196 ;;; FIXME: probably no longer needed after init
197 (defmacro precompile-random-code-segments (&optional system)
198   `(progn
199      (eval-when (:compile-toplevel)
200        (update-dispatch-dfuns))
201      (precompile-function-generators ,system)
202      (precompile-dfun-constructors ,system)
203      (precompile-ctors)))
204 \f
205 ;;; This definition is for interpreted code.
206 (defun pcl-instance-p (x)
207   (typep (layout-of x) 'wrapper))
208
209 ;;; CMU CL comment:
210 ;;;   We define this as STANDARD-INSTANCE, since we're going to
211 ;;;   clobber the layout with some standard-instance layout as soon as
212 ;;;   we make it, and we want the accessor to still be type-correct.
213 #|
214 (defstruct (standard-instance
215             (:predicate nil)
216             (:constructor %%allocate-instance--class ())
217             (:copier nil)
218             (:alternate-metaclass instance
219                                   cl:standard-class
220                                   make-standard-class))
221   (slots nil))
222 |#
223 (!defstruct-with-alternate-metaclass standard-instance
224   :slot-names (slots hash-code)
225   :boa-constructor %make-standard-instance
226   :superclass-name instance
227   :metaclass-name standard-classoid
228   :metaclass-constructor make-standard-classoid
229   :dd-type structure
230   :runtime-type-checks-p nil)
231
232 ;;; Both of these operations "work" on structures, which allows the above
233 ;;; weakening of STD-INSTANCE-P.
234 (defmacro std-instance-slots (x) `(%instance-ref ,x 1))
235 (defmacro std-instance-wrapper (x) `(%instance-layout ,x))
236 ;;; KLUDGE: This one doesn't "work" on structures.  However, we
237 ;;; ensure, in SXHASH and friends, never to call it on structures.
238 (defmacro std-instance-hash (x) `(%instance-ref ,x 2))
239
240 ;;; FIXME: These functions are called every place we do a
241 ;;; CALL-NEXT-METHOD, and probably other places too. It's likely worth
242 ;;; selectively optimizing them with DEFTRANSFORMs and stuff, rather
243 ;;; than just indiscriminately expanding them inline everywhere.
244 (declaim (inline get-slots get-slots-or-nil))
245 (declaim (ftype (function (t) simple-vector) get-slots))
246 (declaim (ftype (function (t) (or simple-vector null)) get-slots-or-nil))
247 (defun get-slots (instance)
248   (if (std-instance-p instance)
249       (std-instance-slots instance)
250       (fsc-instance-slots instance)))
251 (defun get-slots-or-nil (instance)
252   ;; Suppress a code-deletion note.  FIXME: doing the FIXME above,
253   ;; integrating PCL more with the compiler, would remove the need for
254   ;; this icky stuff.
255   (declare (optimize (inhibit-warnings 3)))
256   (when (pcl-instance-p instance)
257     (get-slots instance)))
258
259 (defmacro built-in-or-structure-wrapper (x) `(layout-of ,x))
260
261 (defmacro get-wrapper (inst)
262   (once-only ((wrapper `(wrapper-of ,inst)))
263     `(progn
264        (aver (typep ,wrapper 'wrapper))
265        ,wrapper)))
266
267 ;;; FIXME: could be an inline function or ordinary function (like many
268 ;;; other things around here)
269 (defmacro get-instance-wrapper-or-nil (inst)
270   (once-only ((wrapper `(wrapper-of ,inst)))
271     `(if (typep ,wrapper 'wrapper)
272          ,wrapper
273          nil)))
274 \f
275 ;;;; support for useful hashing of PCL instances
276
277 (defvar *instance-hash-code-random-state* (make-random-state))
278 (defun get-instance-hash-code ()
279   ;; ANSI SXHASH wants us to make a good-faith effort to produce
280   ;; hash-codes that are well distributed within the range of
281   ;; non-negative fixnums, and this RANDOM operation does that, unlike
282   ;; the sbcl<=0.8.16 implementation of this operation as
283   ;; (INCF COUNTER).
284   ;;
285   ;; Hopefully there was no virtue to the old counter implementation
286   ;; that I am insufficiently insightful to insee. -- WHN 2004-10-28
287   (random most-positive-fixnum
288           *instance-hash-code-random-state*))
289
290 (defun sb-impl::sxhash-instance (x)
291   (cond
292     ((std-instance-p x) (std-instance-hash x))
293     ((fsc-instance-p x) (fsc-instance-hash x))
294     (t (bug "SXHASH-INSTANCE called on some weird thing: ~S" x))))
295 \f
296 ;;;; structure-instance stuff
297 ;;;;
298 ;;;; FIXME: Now that the code is SBCL-only, this extra layer of
299 ;;;; abstraction around our native structure representation doesn't
300 ;;;; seem to add anything useful, and could probably go away.
301
302 ;;; The definition of STRUCTURE-TYPE-P was moved to early-low.lisp.
303
304 (defun get-structure-dd (type)
305   (layout-info (classoid-layout (find-classoid type))))
306
307 (defun structure-type-included-type-name (type)
308   (let ((include (dd-include (get-structure-dd type))))
309     (if (consp include)
310         (car include)
311         include)))
312
313 (defun structure-type-slot-description-list (type)
314   (nthcdr (length (let ((include (structure-type-included-type-name type)))
315                     (and include
316                          (dd-slots (get-structure-dd include)))))
317           (dd-slots (get-structure-dd type))))
318
319 (defun structure-slotd-name (slotd)
320   (dsd-name slotd))
321
322 (defun structure-slotd-accessor-symbol (slotd)
323   (dsd-accessor-name slotd))
324
325 (defun structure-slotd-reader-function (slotd)
326   (fdefinition (dsd-accessor-name slotd)))
327
328 (defun structure-slotd-writer-function (type slotd)
329   (if (dsd-read-only slotd)
330       (let ((dd (get-structure-dd type)))
331         (coerce (slot-setter-lambda-form dd slotd) 'function))
332       (fdefinition `(setf ,(dsd-accessor-name slotd)))))
333
334 (defun structure-slotd-type (slotd)
335   (dsd-type slotd))
336
337 (defun structure-slotd-init-form (slotd)
338   (dsd-default slotd))
339
340 ;;; WITH-PCL-LOCK is used around some forms that were previously
341 ;;; protected by WITHOUT-INTERRUPTS, but in a threaded SBCL we don't
342 ;;; have a useful WITHOUT-INTERRUPTS.  In an unthreaded SBCL I'm not
343 ;;; sure what the desired effect is anyway: should we be protecting
344 ;;; against the possibility of recursive calls into these functions
345 ;;; or are we using WITHOUT-INTERRUPTS as WITHOUT-SCHEDULING?
346 ;;;
347 ;;; Users: FORCE-CACHE-FLUSHES, MAKE-INSTANCES-OBSOLETE.  Note that
348 ;;; it's not all certain this is sufficent for threadsafety: do we
349 ;;; just have to protect against simultaneous calls to these mutators,
350 ;;; or actually to stop normal slot access etc at the same time as one
351 ;;; of them runs
352
353 #+sb-thread
354 (progn
355 (defstruct spinlock (value 0))
356 (defvar *pcl-lock* (make-spinlock))
357
358 (defmacro with-pcl-lock (&body body)
359   `(progn
360     (sb-thread::get-spinlock *pcl-lock* 1 (sb-thread::current-thread-id))
361     (unwind-protect
362        (progn ,@body)
363       (setf (spinlock-value *pcl-lock*) 0))))
364 );progn
365
366 #-sb-thread
367 (defmacro with-pcl-lock (&body body)
368   `(progn ,@body))