1.0.41.37: ppc: allocation fixes for threaded builds.
[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
50 (declaim (inline random-fixnum))
51 (defun random-fixnum ()
52   (random (1+ most-positive-fixnum)))
53
54 (defconstant n-fixnum-bits #.(integer-length most-positive-fixnum))
55
56 ;;; Lambda which executes its body (or not) randomly. Used to drop
57 ;;; random cache entries.
58 (defmacro randomly-punting-lambda (lambda-list &body body)
59   (with-unique-names (drops drop-pos)
60     `(let ((,drops (random-fixnum))
61            (,drop-pos n-fixnum-bits))
62        (declare (fixnum ,drops)
63                 (type (integer 0 #.n-fixnum-bits) ,drop-pos))
64        (lambda ,lambda-list
65          (when (logbitp (the unsigned-byte (decf ,drop-pos)) ,drops)
66            (locally ,@body))
67          (when (zerop ,drop-pos)
68            (setf ,drops (random-fixnum)
69                  ,drop-pos n-fixnum-bits))))))
70 \f
71 ;;;; early definition of WRAPPER
72 ;;;;
73 ;;;; Most WRAPPER stuff is defined later, but the DEFSTRUCT itself
74 ;;;; is here early so that things like (TYPEP .. 'WRAPPER) can be
75 ;;;; compiled efficiently.
76
77 ;;; Note that for SBCL, as for CMU CL, the WRAPPER of a built-in or
78 ;;; structure class will be some other kind of SB-KERNEL:LAYOUT, but
79 ;;; this shouldn't matter, since the only two slots that WRAPPER adds
80 ;;; are meaningless in those cases.
81 (defstruct (wrapper
82             (:include layout
83                       ;; KLUDGE: In CMU CL, the initialization default
84                       ;; for LAYOUT-INVALID was NIL. In SBCL, that has
85                       ;; changed to :UNINITIALIZED, but PCL code might
86                       ;; still expect NIL for the initialization
87                       ;; default of WRAPPER-INVALID. Instead of trying
88                       ;; to find out, I just overrode the LAYOUT
89                       ;; default here. -- WHN 19991204
90                       (invalid nil)
91                       ;; This allows quick testing of wrapperness.
92                       (for-std-class-p t))
93             (:constructor make-wrapper-internal)
94             (:copier nil))
95   (instance-slots-layout nil :type list)
96   (class-slots nil :type list))
97 #-sb-fluid (declaim (sb-ext:freeze-type wrapper))
98 \f
99 ;;;; PCL's view of funcallable instances
100
101 (!defstruct-with-alternate-metaclass standard-funcallable-instance
102   ;; KLUDGE: Note that neither of these slots is ever accessed by its
103   ;; accessor name as of sbcl-0.pre7.63. Presumably everything works
104   ;; by puns based on absolute locations. Fun fun fun.. -- WHN 2001-10-30
105   :slot-names (clos-slots name hash-code)
106   :boa-constructor %make-standard-funcallable-instance
107   :superclass-name function
108   :metaclass-name standard-classoid
109   :metaclass-constructor make-standard-classoid
110   :dd-type funcallable-structure
111   ;; Only internal implementation code will access these, and these
112   ;; accesses (slot readers in particular) could easily be a
113   ;; bottleneck, so it seems reasonable to suppress runtime type
114   ;; checks.
115   ;;
116   ;; (Except note KLUDGE above that these accessors aren't used at all
117   ;; (!) as of sbcl-0.pre7.63, so for now it's academic.)
118   :runtime-type-checks-p nil)
119
120 (import 'sb-kernel:funcallable-instance-p)
121
122 (defun set-funcallable-instance-function (fin new-value)
123   (declare (type function new-value))
124   (aver (funcallable-instance-p fin))
125   (setf (funcallable-instance-fun fin) new-value))
126
127 ;;; FIXME: these macros should just go away.  It's not clear whether
128 ;;; the inline functions defined by
129 ;;; !DEFSTRUCT-WITH-ALTERNATE-METACLASS are as efficient as they could
130 ;;; be; ordinary defstruct accessors are defined as source transforms.
131 (defun fsc-instance-p (fin)
132   (funcallable-instance-p fin))
133 (define-compiler-macro fsc-instance-p (fin)
134   `(funcallable-instance-p ,fin))
135 (defmacro fsc-instance-wrapper (fin)
136   `(%funcallable-instance-layout ,fin))
137 (defmacro fsc-instance-slots (fin)
138   `(%funcallable-instance-info ,fin 1))
139 (defmacro fsc-instance-hash (fin)
140   `(%funcallable-instance-info ,fin 3))
141 \f
142 (declaim (inline clos-slots-ref (setf clos-slots-ref)))
143 (declaim (ftype (function (simple-vector index) t) clos-slots-ref))
144 (defun clos-slots-ref (slots index)
145   (svref slots index))
146 (declaim (ftype (function (t simple-vector index) t) (setf clos-slots-ref)))
147 (defun (setf clos-slots-ref) (new-value slots index)
148   (setf (svref slots index) new-value))
149
150 ;;; Note on implementation under CMU CL >=17 and SBCL: STD-INSTANCE-P
151 ;;; is only used to discriminate between functions (including FINs)
152 ;;; and normal instances, so we can return true on structures also. A
153 ;;; few uses of (OR STD-INSTANCE-P FSC-INSTANCE-P) are changed to
154 ;;; PCL-INSTANCE-P.
155 (defun std-instance-p (x)
156   (%instancep x))
157 (define-compiler-macro std-instance-p (x)
158   `(%instancep ,x))
159
160 ;; a temporary definition used for debugging the bootstrap
161 #+sb-show
162 (defun print-std-instance (instance stream depth)
163   (declare (ignore depth))
164   (print-unreadable-object (instance stream :type t :identity t)
165     (let ((class (class-of instance)))
166       (when (or (eq class (find-class 'standard-class nil))
167                 (eq class (find-class 'funcallable-standard-class nil))
168                 (eq class (find-class 'built-in-class nil)))
169         (princ (early-class-name instance) stream)))))
170
171 ;;; This is the value that we stick into a slot to tell us that it is
172 ;;; unbound. It may seem gross, but for performance reasons, we make
173 ;;; this an interned symbol. That means that the fast check to see
174 ;;; whether a slot is unbound is to say (EQ <val> '..SLOT-UNBOUND..).
175 ;;; That is considerably faster than looking at the value of a special
176 ;;; variable. Be careful, there are places in the code which actually
177 ;;; use ..SLOT-UNBOUND.. rather than this variable. So much for
178 ;;; modularity..
179 ;;;
180 ;;; FIXME: Now that we're tightly integrated into SBCL, we could use
181 ;;; the SBCL built-in unbound value token instead. Perhaps if we did
182 ;;; so it would be a good idea to define collections of CLOS slots as
183 ;;; a new type of heap object, instead of using bare SIMPLE-VECTOR, in
184 ;;; order to avoid problems (in the debugger if nowhere else) with
185 ;;; SIMPLE-VECTORs some of whose elements are unbound tokens.
186 (defconstant +slot-unbound+ '..slot-unbound..)
187
188 (defmacro %allocate-static-slot-storage--class (no-of-slots)
189   `(make-array ,no-of-slots :initial-element +slot-unbound+))
190
191 (defmacro std-instance-class (instance)
192   `(wrapper-class* (std-instance-wrapper ,instance)))
193 \f
194 ;;; When given a funcallable instance, SET-FUN-NAME *must* side-effect
195 ;;; that FIN to give it the name. When given any other kind of
196 ;;; function SET-FUN-NAME is allowed to return a new function which is
197 ;;; "the same" except that it has the name.
198 ;;;
199 ;;; In all cases, SET-FUN-NAME must return the new (or same)
200 ;;; function. (Unlike other functions to set stuff, it does not return
201 ;;; the new value.)
202 (defun set-fun-name (fun new-name)
203   #+sb-doc
204   "Set the name of a compiled function object. Return the function."
205   (when (valid-function-name-p fun)
206     (setq fun (fdefinition fun)))
207   (typecase fun
208     (%method-function (setf (%method-function-name fun) new-name))
209     #+sb-eval
210     (sb-eval:interpreted-function
211      (setf (sb-eval:interpreted-function-name fun) new-name))
212     (funcallable-instance ;; KLUDGE: probably a generic function...
213      (cond ((if (eq **boot-state** 'complete)
214                 (typep fun 'generic-function)
215                 (eq (class-of fun) *the-class-standard-generic-function*))
216             (setf (%funcallable-instance-info fun 2) new-name))
217            (t
218             (bug "unanticipated function type")))))
219   ;; Fixup name-to-function mappings in cases where the function
220   ;; hasn't been defined by DEFUN.  (FIXME: is this right?  This logic
221   ;; comes from CMUCL).  -- CSR, 2004-12-31
222   (when (and (consp new-name)
223              (member (car new-name) '(slow-method fast-method slot-accessor)))
224     (setf (fdefinition new-name) fun))
225   fun)
226 \f
227 ;;; FIXME: probably no longer needed after init
228 (defmacro precompile-random-code-segments (&optional system)
229   `(progn
230      (eval-when (:compile-toplevel)
231        (update-dispatch-dfuns))
232      (precompile-function-generators ,system)
233      (precompile-dfun-constructors ,system)
234      (precompile-ctors)))
235 \f
236 ;;; This definition is for interpreted code.
237 (defun pcl-instance-p (x)
238   (typep (layout-of x) 'wrapper))
239
240 ;;; CMU CL comment:
241 ;;;   We define this as STANDARD-INSTANCE, since we're going to
242 ;;;   clobber the layout with some standard-instance layout as soon as
243 ;;;   we make it, and we want the accessor to still be type-correct.
244 #|
245 (defstruct (standard-instance
246             (:predicate nil)
247             (:constructor %%allocate-instance--class ())
248             (:copier nil)
249             (:alternate-metaclass instance
250                                   cl:standard-class
251                                   make-standard-class))
252   (slots nil))
253 |#
254 (!defstruct-with-alternate-metaclass standard-instance
255   :slot-names (slots hash-code)
256   :boa-constructor %make-standard-instance
257   :superclass-name t
258   :metaclass-name standard-classoid
259   :metaclass-constructor make-standard-classoid
260   :dd-type structure
261   :runtime-type-checks-p nil)
262
263 ;;; Both of these operations "work" on structures, which allows the above
264 ;;; weakening of STD-INSTANCE-P.
265 (defmacro std-instance-slots (x) `(%instance-ref ,x 1))
266 (defmacro std-instance-wrapper (x) `(%instance-layout ,x))
267 ;;; KLUDGE: This one doesn't "work" on structures.  However, we
268 ;;; ensure, in SXHASH and friends, never to call it on structures.
269 (defmacro std-instance-hash (x) `(%instance-ref ,x 2))
270
271 ;;; FIXME: These functions are called every place we do a
272 ;;; CALL-NEXT-METHOD, and probably other places too. It's likely worth
273 ;;; selectively optimizing them with DEFTRANSFORMs and stuff, rather
274 ;;; than just indiscriminately expanding them inline everywhere.
275 (declaim (inline get-slots get-slots-or-nil))
276 (declaim (ftype (function (t) simple-vector) get-slots))
277 (declaim (ftype (function (t) (or simple-vector null)) get-slots-or-nil))
278 (defun get-slots (instance)
279   (if (std-instance-p instance)
280       (std-instance-slots instance)
281       (fsc-instance-slots instance)))
282 (defun get-slots-or-nil (instance)
283   ;; Suppress a code-deletion note.  FIXME: doing the FIXME above,
284   ;; integrating PCL more with the compiler, would remove the need for
285   ;; this icky stuff.
286   (declare (optimize (inhibit-warnings 3)))
287   (when (pcl-instance-p instance)
288     (get-slots instance)))
289
290 (defmacro get-wrapper (inst)
291   (once-only ((wrapper `(wrapper-of ,inst)))
292     `(progn
293        (aver (typep ,wrapper 'wrapper))
294        ,wrapper)))
295
296 ;;; FIXME: could be an inline function or ordinary function (like many
297 ;;; other things around here)
298 (defmacro get-instance-wrapper-or-nil (inst)
299   (once-only ((wrapper `(wrapper-of ,inst)))
300     `(if (typep ,wrapper 'wrapper)
301          ,wrapper
302          nil)))
303 \f
304 ;;;; support for useful hashing of PCL instances
305
306 (defvar *instance-hash-code-random-state* (make-random-state))
307 (defun get-instance-hash-code ()
308   ;; ANSI SXHASH wants us to make a good-faith effort to produce
309   ;; hash-codes that are well distributed within the range of
310   ;; non-negative fixnums, and this RANDOM operation does that, unlike
311   ;; the sbcl<=0.8.16 implementation of this operation as
312   ;; (INCF COUNTER).
313   ;;
314   ;; Hopefully there was no virtue to the old counter implementation
315   ;; that I am insufficiently insightful to insee. -- WHN 2004-10-28
316   (random most-positive-fixnum
317           *instance-hash-code-random-state*))
318
319 (defun sb-impl::sxhash-instance (x)
320   (cond
321     ((std-instance-p x) (std-instance-hash x))
322     ((fsc-instance-p x) (fsc-instance-hash x))
323     (t (bug "SXHASH-INSTANCE called on some weird thing: ~S" x))))
324 \f
325 ;;;; structure-instance stuff
326 ;;;;
327 ;;;; FIXME: Now that the code is SBCL-only, this extra layer of
328 ;;;; abstraction around our native structure representation doesn't
329 ;;;; seem to add anything useful, and could probably go away.
330
331 ;;; The definition of STRUCTURE-TYPE-P was moved to early-low.lisp.
332
333 (defun structure-type-slot-description-list (type)
334   (let* ((dd (find-defstruct-description type))
335          (include (dd-include dd))
336          (all-slots (dd-slots dd)))
337     (multiple-value-bind (super slot-overrides)
338         (if (consp include)
339             (values (car include) (mapcar #'car (cdr include)))
340             (values include nil))
341       (let ((included-slots
342              (when super
343                (dd-slots (find-defstruct-description super)))))
344         (loop for slot = (pop all-slots)
345               for included-slot = (pop included-slots)
346               while slot
347               when (or (not included-slot)
348                        (member (dsd-name included-slot) slot-overrides :test #'eq))
349               collect slot)))))
350
351 (defun structure-slotd-name (slotd)
352   (dsd-name slotd))
353
354 (defun structure-slotd-accessor-symbol (slotd)
355   (dsd-accessor-name slotd))
356
357 (defun structure-slotd-reader-function (slotd)
358   (fdefinition (dsd-accessor-name slotd)))
359
360 (defun structure-slotd-writer-function (type slotd)
361   (if (dsd-read-only slotd)
362       (let ((dd (find-defstruct-description type)))
363         (coerce (slot-setter-lambda-form dd slotd) 'function))
364       (fdefinition `(setf ,(dsd-accessor-name slotd)))))
365
366 (defun structure-slotd-type (slotd)
367   (dsd-type slotd))
368
369 (defun structure-slotd-init-form (slotd)
370   (dsd-default slotd))
371 \f
372 ;;; method function stuff.
373 ;;;
374 ;;; PCL historically included a so-called method-fast-function, which
375 ;;; is essentially a method function but with (a) a precomputed
376 ;;; continuation for CALL-NEXT-METHOD and (b) a permutation vector for
377 ;;; slot access.  [ FIXME: see if we can understand these two
378 ;;; optimizations before commit. ]  However, the presence of the
379 ;;; fast-function meant that we violated AMOP and the effect of the
380 ;;; :FUNCTION initarg, and furthermore got to potentially confusing
381 ;;; situations where the function and the fast-function got out of
382 ;;; sync, so that calling (method-function method) with the defined
383 ;;; protocol would do different things from (call-method method) in
384 ;;; method combination.
385 ;;;
386 ;;; So we define this internal method function structure, which we use
387 ;;; when we create a method function ourselves.  This means that we
388 ;;; can hang the various bits of information that we want off the
389 ;;; method function itself, and also that if a user overrides method
390 ;;; function creation there is no danger of having the system get
391 ;;; confused.
392 (!defstruct-with-alternate-metaclass %method-function
393   :slot-names (fast-function name)
394   :boa-constructor %make-method-function
395   :superclass-name function
396   :metaclass-name static-classoid
397   :metaclass-constructor make-static-classoid
398   :dd-type funcallable-structure)
399