;;; Return the compiler layout for NAME. (The class referred to by
;;; NAME must be a structure-like class.)
(defun compiler-layout-or-lose (name)
- #+sb-xc (/show0 "entering COMPILER-LAYOUT-OR-LOSE")
(let ((res (info :type :compiler-layout name)))
(cond ((not res)
(error "Class is not yet defined or was undefined: ~S" name))
\f
;;;; shared machinery for inline and out-of-line slot accessor functions
-;;; an alist mapping from raw slot type to the operator used to access
-;;; the raw slot
-;;;
-;;; FIXME: should be shared
(eval-when (:compile-toplevel :load-toplevel :execute)
- (defvar *raw-type->rawref-fun-name*
- '(;; The compiler thinks that the raw data vector is a vector of
- ;; unsigned bytes, so if the slot we want to access actually *is*
- ;; an unsigned byte, it'll access the slot for us even if we don't
- ;; lie to it at all.
- (unsigned-byte . aref)
- ;; "A lie can travel halfway round the world while the truth is
- ;; putting on its shoes." -- Mark Twain
- (single-float . %raw-ref-single)
- (double-float . %raw-ref-double)
- #!+long-float (long-float . %raw-ref-long)
- (complex-single-float . %raw-ref-complex-single)
- (complex-double-float . %raw-ref-complex-double)
- #!+long-float (complex-long-float . %raw-ref-complex-long))))
-\f
-;;;; generating out-of-line slot accessor functions
-
-;;; FIXME: Ideally, the presence of the type checks in the functions
-;;; here would be conditional on the optimization policy at the point
-;;; of expansion of DEFSTRUCT. (For now we're just doing the simpler
-;;; thing, putting in the type checks unconditionally.)
-
-;;; Return (VALUES SLOT-READER-FUN SLOT-WRITER-FUN).
-(defun slot-accessor-funs (dd dsd)
- #+sb-xc (/show0 "entering SLOT-ACCESSOR-FUNS")
-
- ;; various code generators
- ;;
- ;; Note: They're only minimally parameterized, and cavalierly grab
- ;; things like INSTANCE and DSD-INDEX from the namespace they're
- ;; expanded in.
- (macrolet (;; code shared between funcallable instance case and the
- ;; ordinary STRUCTURE-OBJECT case: Handle native
- ;; structures with LAYOUTs and (possibly) raw slots.
- (%native-slot-accessor-funs (dd-ref-fun-name)
- (let ((instance-type-check-form
- '(%check-structure-type-from-layout instance layout)))
- (/show "macroexpanding %NATIVE-SLOT-ACCESSOR-FUNS" dd-ref-fun-name instance-type-check-form)
- `(let ((layout (dd-layout-or-lose dd))
- (dsd-raw-type (dsd-raw-type dsd)))
- #+sb-xc (/show0 "in %NATIVE-SLOT-ACCESSOR-FUNS macroexpanded code")
- ;; Map over all the possible RAW-TYPEs, compiling
- ;; a different closure-function for each one, so
- ;; that once the COND over RAW-TYPEs happens (at
- ;; the time closure is allocated) there are no
- ;; more decisions to be made and things execute
- ;; reasonably efficiently.
- (cond
- ;; nonraw slot case
- ((eql dsd-raw-type t)
- #+sb-xc (/show0 "in nonraw slot case")
- (%slotplace-accessor-funs
- (,dd-ref-fun-name instance dsd-index)
- ,instance-type-check-form))
- ;; raw slot cases
- ,@(mapcar (lambda (raw-type-and-rawref-fun-name)
- (destructuring-bind (raw-type
- . rawref-fun-name)
- raw-type-and-rawref-fun-name
- `((equal dsd-raw-type ',raw-type)
- #+sb-xc (/show0 "in raw slot case")
- (let ((raw-index (dd-raw-index dd)))
- (%slotplace-accessor-funs
- (,rawref-fun-name (,dd-ref-fun-name
- instance
- raw-index)
- dsd-index)
- ,instance-type-check-form)))))
- *raw-type->rawref-fun-name*)
- ;; oops
- (t
- (error "internal error: unexpected DSD-RAW-TYPE ~S"
- dsd-raw-type))))))
- ;; code shared between DEFSTRUCT :TYPE LIST and
- ;; DEFSTRUCT :TYPE VECTOR cases: Handle the "typed
- ;; structure" case, with no LAYOUTs and no raw slots.
- (%colontyped-slot-accessor-funs () (error "stub"))
- ;; the common structure of the raw-slot and not-raw-slot
- ;; cases, defined in terms of the writable SLOTPLACE. All
- ;; possible flavors of slot access should be able to pass
- ;; through here.
- (%slotplace-accessor-funs (slotplace instance-type-check-form)
- (/show "macroexpanding %SLOTPLACE-ACCESSOR-FUNS" slotplace instance-type-check-form)
- `(values (lambda (instance)
- (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined reader")
- ,instance-type-check-form
- (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
- ,slotplace)
- (let ((typecheckfun (typespec-typecheckfun dsd-type)))
- (lambda (new-value instance)
- (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined writer")
- ,instance-type-check-form
- (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
- (funcall typecheckfun new-value)
- (/noshow0 "back from TYPECHECKFUN")
- (setf ,slotplace new-value))))))
-
- (let ((dsd-index (dsd-index dsd))
- (dsd-type (dsd-type dsd)))
-
- #+sb-xc (/show0 "got DSD-TYPE=..")
- #+sb-xc (/hexstr dsd-type)
- (ecase (dd-type dd)
-
- ;; native structures
- (structure
- #+sb-xc (/show0 "case of DSD-TYPE = STRUCTURE")
- (%native-slot-accessor-funs %instance-ref))
-
- ;; structures with the :TYPE option
-
- ;; FIXME: Worry about these later..
- #|
- ;; In :TYPE LIST and :TYPE VECTOR structures, ANSI specifies the
- ;; layout completely, so that raw slots are impossible.
- (list
- (dd-type-slot-accessor-funs nth-but-with-sane-arg-order
- `(%check-structure-type-from-dd
- :maybe-raw-p nil))
- (vector
- (dd-type-slot-accessor-funs aref
- :maybe-raw-p nil)))
- |#
- ))))
-\f
-;;;; baby steps for the new out-of-line slot accessor functions
-;;;;
-;;;; REMOVEME after new structure code works
-
-#|
-(in-package :sb-kernel)
-
-(defstruct foo
- ;; vanilla slots
- a
- (b 5 :type package :read-only t)
- ;; raw slots
- (x 5 :type (unsigned-byte 32))
- (y 5.0 :type single-float :read-only t))
-
-(load "/usr/stuff/sbcl/src/cold/chill")
-(cl-user:fasl "/usr/stuff/sbcl/src/code/typecheckfuns")
-(cl-user:fasl "/usr/stuff/outsacc")
-
-(let* ((foo-layout (compiler-layout-or-lose 'foo))
- (foo-dd (layout-info foo-layout))
- (foo-dsds (dd-slots foo-dd))
- (foo-a-dsd (find "A" foo-dsds :test #'string= :key #'dsd-%name))
- (foo-b-dsd (find "B" foo-dsds :test #'string= :key #'dsd-%name))
- (foo-x-dsd (find "X" foo-dsds :test #'string= :key #'dsd-%name))
- (foo-y-dsd (find "X" foo-dsds :test #'string= :key #'dsd-%name))
- (foo (make-foo :a 'avalue
- :b (find-package :cl)
- :x 50)))
- (declare (type layout foo-layout))
- (declare (type defstruct-description foo-dd))
- (declare (type defstruct-slot-description foo-a-dsd))
-
- (cl-user:/show foo)
-
- (multiple-value-bind (foo-a-reader foo-a-writer)
- (slot-accessor-funs foo-dd foo-a-dsd)
-
- ;; basic functionality
- (cl-user:/show foo-a-reader)
- (cl-user:/show (funcall foo-a-reader foo))
- (aver (eql (funcall foo-a-reader foo) 'avalue))
- (cl-user:/show foo-a-writer)
- (cl-user:/show (funcall foo-a-writer 'replacedavalue foo))
- (cl-user:/show "new" (funcall foo-a-reader foo))
- (aver (eql (funcall foo-a-reader foo) 'replacedavalue))
-
- ;; type checks on FOO-ness of instance argument
- (cl-user:/show (nth-value 1 (ignore-errors (funcall foo-a-reader 3))))
- (aver (typep (nth-value 1 (ignore-errors (funcall foo-a-reader 3)))
- 'type-error))
- (aver (typep (nth-value 1 (ignore-errors (funcall foo-a-writer 3 4)))
- 'type-error)))
-
- ;; type checks on written slot value
- (multiple-value-bind (foo-b-reader foo-b-writer)
- (slot-accessor-funs foo-dd foo-b-dsd)
- (cl-user:/show "old" (funcall foo-b-reader foo))
- (aver (not (eql (funcall foo-b-reader foo) (find-package :cl-user))))
- (funcall foo-b-writer (find-package :cl-user) foo)
- (cl-user:/show "new" (funcall foo-b-reader foo))
- (aver (eql (funcall foo-b-reader foo) (find-package :cl-user)))
- (aver (typep (nth-value 1 (ignore-errors (funcall foo-b-writer 5 foo)))
- 'type-error))
- (aver (eql (funcall foo-b-reader foo) (find-package :cl-user))))
-
- ;; raw slots
- (cl-user:/describe foo-x-dsd)
- (cl-user:/describe foo-y-dsd)
- (multiple-value-bind (foo-x-reader foo-x-writer)
- (slot-accessor-funs foo-dd foo-x-dsd)
- (multiple-value-bind (foo-y-reader foo-y-writer)
- (slot-accessor-funs foo-dd foo-y-dsd)
-
- ;; basic functionality for (UNSIGNED-BYTE 32) slot
- (cl-user:/show foo-x-reader)
- (cl-user:/show (funcall foo-x-reader foo))
- (aver (eql (funcall foo-x-reader foo) 50))
- (cl-user:/show foo-x-writer)
- (cl-user:/show (funcall foo-x-writer 14 foo))
- (cl-user:/show "new" (funcall foo-x-reader foo))
- (aver (eql (funcall foo-x-reader foo) 14)))
-
- ;; type check for (UNSIGNED-BYTE 32) slot
- (/show "to do: type check X")
-
- ;; SINGLE-FLOAT slot
- (/show "to do: Y")))
-|#
+ ;; information about how a slot of a given DSD-RAW-TYPE is to be accessed
+ (defstruct raw-slot-data
+ ;; the raw slot type, or T for a non-raw slot
+ ;;
+ ;; (Raw slots are allocated in the raw slots array in a vector which
+ ;; the GC doesn't need to scavenge. Non-raw slots are in the
+ ;; ordinary place you'd expect, directly indexed off the instance
+ ;; pointer.)
+ (raw-type (missing-arg) :type (or symbol cons) :read-only t)
+ ;; What operator is used (on the raw data vector) to access a slot
+ ;; of this type?
+ (accessor-name (missing-arg) :type symbol :read-only t)
+ ;; How many words are each value of this type? (This is used to
+ ;; rescale the offset into the raw data vector.)
+ (n-words (missing-arg) :type (and index (integer 1)) :read-only t))
+
+ (defvar *raw-slot-data-list*
+ (list
+ ;; The compiler thinks that the raw data vector is a vector of
+ ;; word-sized unsigned bytes, so if the slot we want to access
+ ;; actually *is* an unsigned byte, it'll access the slot for us
+ ;; even if we don't lie to it at all, just let it use normal AREF.
+ (make-raw-slot-data :raw-type 'unsigned-byte
+ :accessor-name 'aref
+ :n-words 1)
+ ;; In the other cases, we lie to the compiler, making it use
+ ;; some low-level AREFish access in order to pun the hapless
+ ;; bits into some other-than-unsigned-byte meaning.
+ ;;
+ ;; "A lie can travel halfway round the world while the truth is
+ ;; putting on its shoes." -- Mark Twain
+ (make-raw-slot-data :raw-type 'single-float
+ :accessor-name '%raw-ref-single
+ :n-words 1)
+ (make-raw-slot-data :raw-type 'double-float
+ :accessor-name '%raw-ref-double
+ :n-words 2)
+ (make-raw-slot-data :raw-type 'complex-single-float
+ :accessor-name '%raw-ref-complex-single
+ :n-words 2)
+ (make-raw-slot-data :raw-type 'complex-double-float
+ :accessor-name '%raw-ref-complex-double
+ :n-words 4)
+ #!+long-float
+ (make-raw-slot-data :raw-type long-float
+ :accessor-name '%raw-ref-long
+ :n-words #!+x86 3 #!+sparc 4)
+ #!+long-float
+ (make-raw-slot-data :raw-type complex-long-float
+ :accessor-name '%raw-ref-complex-long
+ :n-words #!+x86 6 #!+sparc 8))))
\f
;;;; the legendary DEFSTRUCT macro itself (both CL:DEFSTRUCT and its
;;;; close personal friend SB!XC:DEFSTRUCT)
;; non-compact code. In this context, we'd rather have
;; compact, cold-loadable code. -- WHN 19990928
(declare (notinline sb!xc:find-class))
- #+sb-xc (/show0 "beginning CLASS-METHOD-DEFINITIONS forms")
,@(let ((pf (dd-print-function defstruct))
(po (dd-print-object defstruct))
(x (gensym))
,@(let ((def-con (dd-default-constructor defstruct)))
(when (and def-con (not (dd-alternate-metaclass defstruct)))
`((setf (structure-class-constructor (sb!xc:find-class ',name))
- #',def-con))))
- #+sb-xc (/show0 "done with CLASS-METHOD-DEFINITIONS forms")))))
-;;; FIXME: I really would like to make structure accessors less
-;;; special, just ordinary inline functions. (Or perhaps inline
-;;; functions with special compact implementations of their
-;;; expansions, to avoid bloating the system.)
+ #',def-con))))))))
;;; shared logic for CL:DEFSTRUCT and SB!XC:DEFSTRUCT
(defmacro !expander-for-defstruct (name-and-options
(if (dd-class-p dd)
(let ((inherits (inherits-for-structure dd)))
`(progn
- (/show0 "beginning macroexpanded DEFSTRUCT code")
(eval-when (:compile-toplevel :load-toplevel :execute)
(%compiler-defstruct ',dd ',inherits))
- (/show0 "back from %COMPILER-DEFSTRUCT")
(%defstruct ',dd ',inherits)
- (/show0 "back from %DEFSTRUCT")
,@(unless expanding-into-code-for-xc-host-p
- (append #|(raw-accessor-definitions dd)|# ; REMOVEME
- (predicate-definitions dd)
- ;; FIXME: We've inherited from CMU CL nonparallel
+ (append ;; FIXME: We've inherited from CMU CL nonparallel
;; code for creating copiers for typed and untyped
;; structures. This should be fixed.
;(copier-definition dd)
(constructor-definitions dd)
(class-method-definitions dd)))
- (/show0 "done with macroexpanded DEFSTRUCT code")
',name))
`(progn
- (/show0 "beginning macroexpanded typed DEFSTRUCT code")
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf (info :typed-structure :info ',name) ',dd))
,@(unless expanding-into-code-for-xc-host-p
(typed-predicate-definitions dd)
(typed-copier-definitions dd)
(constructor-definitions dd)))
- (/show0 "done with macroexpanded typed DEFSTRUCT code")
',name)))))
(sb!xc:defmacro defstruct (name-and-options &rest slot-descriptions)
\f
;;;; functions to generate code for various parts of DEFSTRUCT definitions
-;;; REMOVEME: no longer used
-#|
-;;; Return forms to define readers and writers for raw slots as inline
-;;; functions.
-(defun raw-accessor-definitions (dd)
- (let* ((name (dd-name dd))
- (dtype (dd-declarable-type dd)))
- (collect ((res))
- (dolist (slot (dd-slots dd))
- (let ((slot-type (dsd-type slot))
- (accessor-name (dsd-accessor-name slot))
- (argname (gensym "ARG"))
- (nvname (gensym "NEW-VALUE-")))
- (multiple-value-bind (accessor offset data)
- (slot-accessor-form dd slot argname)
- ;; When accessor exists and is raw
- (when (and accessor-name
- (not (eq accessor-name '%instance-ref)))
- (res `(/show0 "doing one slot, ACCESSOR-NAME=.."))
- (res `(/hexstr ',accessor-name))
- (res `(declaim (inline ,accessor-name)))
- (res `(/show0 "done with reader DECLAIM INLINE"))
- (res `(declaim (ftype (function (,dtype) ,slot-type)
- ,accessor-name)))
- (res `(/show0 "done with reader DECLAIM FTYPE, doing DEFUN"))
- (res `(defun ,accessor-name (,argname)
- ;; Note: The DECLARE here might seem redundant
- ;; with the DECLAIM FTYPE above, but it's not:
- ;; If we're not at toplevel, the PROCLAIM inside
- ;; the DECLAIM doesn't get executed until after
- ;; this function is compiled.
- (declare (type ,dtype ,argname))
- (truly-the ,slot-type (,accessor ,data ,offset))))
- (unless (dsd-read-only slot)
- (res `(/show0 "doing writer DECLAIM INLINE"))
- (res `(declaim (inline (setf ,accessor-name))))
- (res `(/show0 "doing writer DECLAIM FTYPE"))
- (res `(declaim (ftype (function (,slot-type ,dtype) ,slot-type)
- (setf ,accessor-name))))
- ;; FIXME: I rewrote this somewhat from the CMU CL definition.
- ;; Do some basic tests to make sure that reading and writing
- ;; raw slots still works correctly.
- (res `(/show0 "doing writer DEFUN"))
- (res `(defun (setf ,accessor-name) (,nvname ,argname)
- (declare (type ,dtype ,argname))
- (setf (,accessor ,data ,offset) ,nvname)
- ,nvname)))
- (res `(/show0 "done with one slot"))))))
- `((/show0 "beginning RAW-ACCESSOR-DEFINITIONS forms")
- ,@(res)
- (/show0 "done with RAW-ACCESSOR-DEFINITIONS forms")))))
-|#
-
-;;; Return a list of forms which create a predicate for an untyped DEFSTRUCT.
-(defun predicate-definitions (dd)
- (let ((pred (dd-predicate-name dd))
- (argname (gensym "ARG")))
- (and pred
- `((/show0 "beginning PREDICATE-DEFINITIONS forms")
- (protect-cl ',pred)
- (declaim (inline ,pred))
- (defun ,pred (,argname)
- (declare (optimize (speed 3) (safety 0)))
- (typep-to-layout ,argname
- (compile-time-find-layout ,(dd-name dd))))
- (/show0 "done with PREDICATE-DEFINITIONS forms")))))
-
-;;; Return a list of forms which create a predicate function for a typed
-;;; DEFSTRUCT.
+;;; Return a list of forms which create a predicate function for a
+;;; typed DEFSTRUCT.
(defun typed-predicate-definitions (defstruct)
(let ((name (dd-name defstruct))
(predicate-name (dd-predicate-name defstruct))
,(cdr (car (last (find-name-indices defstruct)))))
',name))))))))
-;;; FIXME: We've inherited from CMU CL code to do typed structure copiers
-;;; in a completely different way than untyped structure copiers. Fix this.
-;;; (This function was my first attempt to fix this, but I stopped before
-;;; figuring out how to install it completely and remove the parallel
-;;; code which simply SETF's the FDEFINITION of the DD-COPIER name.
-#|
-;;; Return the copier definition for an untyped DEFSTRUCT.
-(defun copier-definition (dd)
- (when (dd-copier dd)
- (let ((argname (gensym)))
- `(progn
- (protect-cl ',(dd-copier dd))
- (defun ,(dd-copier dd) (,argname)
- (declare (type ,(dd-name dd) ,argname))
- (copy-structure ,argname))))))
-|#
-
;;; Return a list of forms to create a copier function of a typed DEFSTRUCT.
(defun typed-copier-definitions (defstruct)
(when (dd-copier-name defstruct)
(t (error "unknown DEFSTRUCT option:~% ~S" option)))))
;;; Given name and options, return a DD holding that info.
-(eval-when (:compile-toplevel :load-toplevel :execute)
(defun parse-defstruct-name-and-options (name-and-options)
(destructuring-bind (name &rest options) name-and-options
(aver name) ; A null name doesn't seem to make sense here.
(dolist (slot-description slot-descriptions)
(allocate-1-slot result (parse-1-dsd result slot-description)))
result))
-
-) ; EVAL-WHEN
\f
;;;; stuff to parse slot descriptions
;;; RAW? is true if TYPE should be stored in a raw slot.
;;; RAW-TYPE is the raw slot type, or NIL if no raw slot.
;;; WORDS is the number of words in the raw slot, or NIL if no raw slot.
+;;;
+;;; FIXME: This should use the data in *RAW-SLOT-DATA-LIST*.
(defun structure-raw-slot-type-and-size (type)
- (/noshow "in STRUCTURE-RAW-SLOT-TYPE-AND-SIZE" type (sb!xc:subtypep type 'fixnum))
(cond #+nil
(;; FIXME: For now we suppress raw slots, since there are various
;; issues about the way that the cross-compiler handles them.
((and (sb!xc:subtypep type '(unsigned-byte 32))
(multiple-value-bind (fixnum? fixnum-certain?)
(sb!xc:subtypep type 'fixnum)
- (/noshow fixnum? fixnum-certain?)
;; (The extra test for FIXNUM-CERTAIN? here is
;; intended for bootstrapping the system. In
;; particular, in sbcl-0.6.2, we set up LAYOUT before
;;; yet for the raw data vector, then do it. Raw objects are aligned
;;; on the unit of their size.
(defun allocate-1-slot (dd dsd)
- #+sb-xc (/show0 "entering ALLOCATE-1-SLOT")
(multiple-value-bind (raw? raw-type words)
(if (eq (dd-type dd) 'structure)
(structure-raw-slot-type-and-size (dsd-type dsd))
(values nil nil nil))
- (/noshow "ALLOCATE-1-SLOT" dsd raw? raw-type words)
(cond ((not raw?)
(setf (dsd-index dsd) (dd-length dd))
(incf (dd-length dd)))
(setf (dsd-raw-type dsd) raw-type)
(setf (dsd-index dsd) (dd-raw-length dd))
(incf (dd-raw-length dd) words))))
- #+sb-xc (/show0 "leaving ALLOCATE-1-SLOT")
(values))
(defun typed-structure-info-or-lose (name)
(vector super)))))
;;; Do miscellaneous (LOAD EVAL) time actions for the structure
-;;; described by DD. Create the class & LAYOUT, checking for
+;;; described by DD. Create the class and LAYOUT, checking for
;;; incompatible redefinition. Define those functions which are
;;; sufficiently stereotyped that we can implement them as standard
;;; closures.
(defun %defstruct (dd inherits)
(declare (type defstruct-description dd))
- #+sb-xc (/show0 "entering %DEFSTRUCT")
-
;; We set up LAYOUTs even in the cross-compilation host.
(multiple-value-bind (class layout old-layout)
(ensure-structure-class dd inherits "current" "new")
(setq layout (class-layout class))))
(setf (sb!xc:find-class (dd-name dd)) class)
- ;; It doesn't make sense to do these in the cross-compilation host.
+ ;; Various other operations only make sense on the target SBCL.
#-sb-xc-host
- (progn
- #+sb-xc (/show0 "doing #+SB-XC stuff in %DEFSTRUCT")
- (remhash (dd-name dd) *typecheckfuns*)
- (%target-defstruct dd layout)
- (when (dd-doc dd)
- (setf (fdocumentation (dd-name dd) 'type)
- (dd-doc dd)))
- #+sb-xc (/show0 "done with #+SB-XC stuff in %DEFSTRUCT")
- ))
-
- #+sb-xc (/show0 "leaving %DEFSTRUCT")
+ (%target-defstruct dd layout))
+
(values))
\f
;;; Return a form describing the writable place used for this slot
(raw-type (dsd-raw-type dsd)))
(if (eq raw-type t) ; if not raw slot
`(,ref ,instance-name ,(dsd-index dsd))
- (let (;; the operator that we'll use to access one value in
- ;; the raw data vector
- (rawref (ecase raw-type
- ;; The compiler thinks that the raw data
- ;; vector is a vector of unsigned bytes, so if
- ;; the slot we want to access actually *is* an
- ;; unsigned byte, it'll access the slot for
- ;; us even if we don't lie to it at all.
- (unsigned-byte 'aref)
- ;; "A lie can travel halfway round the world while
- ;; the truth is putting on its shoes." -- Mark Twain
- (single-float '%raw-ref-single)
- (double-float '%raw-ref-double)
- #!+long-float (long-float '%raw-ref-long)
- (complex-single-float '%raw-ref-complex-single)
- (complex-double-float '%raw-ref-complex-double)
- #!+long-float (complex-long-float
- '%raw-ref-complex-long))))
- `(,rawref (,ref ,instance-name ,(dd-raw-index dd))
- ,(dsd-index dsd))))))
+ (let* ((raw-slot-data (find raw-type *raw-slot-data-list*
+ :key #'raw-slot-data-raw-type
+ :test #'equal))
+ (raw-slot-accessor (raw-slot-data-accessor-name raw-slot-data))
+ (raw-n-words (raw-slot-data-n-words raw-slot-data)))
+ (multiple-value-bind (scaled-dsd-index misalignment)
+ (floor (dsd-index dsd) raw-n-words)
+ (aver (zerop misalignment))
+ `(,raw-slot-accessor (,ref ,instance-name ,(dd-raw-index dd))
+ ,scaled-dsd-index))))))
;;; Return inline expansion designators (i.e. values suitable for
-;;; (INFO :FUNCTION :INLINE-EXPANSSION-DESIGNATOR ..)) for the reader
+;;; (INFO :FUNCTION :INLINE-EXPANSION-DESIGNATOR ..)) for the reader
;;; and writer functions of the slot described by DSD.
-(defun accessor-inline-expansion-designators (dd dsd)
- (values (lambda ()
- `(lambda (instance)
- (declare (type ,(dd-name dd) instance))
- (truly-the ,(dsd-type dsd)
- ,(%accessor-place-form dd dsd 'instance))))
- (lambda ()
- `(lambda (new-value instance)
- (declare (type ,(dsd-type dsd) new-value))
- (declare (type ,(dd-name dd) structure-object))
- (setf ,(%accessor-place-form dd dsd 'instance) new-value)))))
+(defun slot-accessor-inline-expansion-designators (dd dsd)
+ (let ((instance-type-decl `(declare (type ,(dd-name dd) instance)))
+ (accessor-place-form (%accessor-place-form dd dsd 'instance))
+ (dsd-type (dsd-type dsd)))
+ (values (lambda ()
+ `(lambda (instance)
+ ,instance-type-decl
+ (truly-the ,dsd-type ,accessor-place-form)))
+ (lambda ()
+ `(lambda (new-value instance)
+ (declare (type ,dsd-type new-value))
+ ,instance-type-decl
+ (setf ,accessor-place-form new-value))))))
+
+;;; Return a LAMBDA form which can be used to set a slot.
+(defun slot-setter-lambda-form (dd dsd)
+ (funcall (nth-value 1
+ (slot-accessor-inline-expansion-designators dd dsd))))
;;; core compile-time setup of any class with a LAYOUT, used even by
;;; !DEFSTRUCT-WITH-ALTERNATE-METACLASS weirdosities
(inherits (vector (find-layout t)
(find-layout 'instance))))
- (/show "entering %COMPILER-SET-UP-LAYOUT for" (dd-name dd))
-
(multiple-value-bind (class layout old-layout)
(multiple-value-bind (clayout clayout-p)
(info :type :compiler-layout (dd-name dd))
"compiled"
:compiler-layout clayout))
(cond (old-layout
- (/show "non-NIL" old-layout)
(undefine-structure (layout-class old-layout))
(when (and (class-subclasses class)
(not (eq layout old-layout)))
(setf (info :type :compiler-layout (dd-name dd)) layout))
- (/show0 "leaving %COMPILER-SET-UP-LAYOUT")
-
(values))
;;; Do (COMPILE LOAD EVAL)-time actions for the normal (not
;;; ALTERNATE-LAYOUT) DEFSTRUCT described by DD.
(defun %compiler-defstruct (dd inherits)
(declare (type defstruct-description dd))
- #+sb-xc (/show0 "entering %COMPILER-DEFSTRUCT")
(%compiler-set-up-layout dd inherits)
(let ((predicate-name (dd-predicate-name dd)))
(when predicate-name
- (sb!xc:proclaim `(ftype (function (t) t) ,predicate-name))))
+ (sb!xc:proclaim `(ftype (function (t) t) ,predicate-name))
+ ;; Provide inline expansion (or not).
+ (ecase (dd-type dd)
+ ((structure funcallable-structure)
+ ;; Let the predicate be inlined.
+ (setf (info :function :inline-expansion-designator predicate-name)
+ (lambda ()
+ `(lambda (x)
+ ;; This dead simple definition works because the
+ ;; type system knows how to generate inline type
+ ;; tests for instances.
+ (typep x ',(dd-name dd))))
+ (info :function :inlinep predicate-name)
+ :inline))
+ ((list vector)
+ ;; Just punt. We could provide inline expansions for :TYPE
+ ;; LIST and :TYPE VECTOR predicates too, but it'd be a
+ ;; little messier and we don't bother. (Does anyway use
+ ;; typed DEFSTRUCTs at all, let alone for high
+ ;; performance?)
+ ))))
(dolist (dsd (dd-slots dd))
(let* ((accessor-name (dsd-accessor-name dsd))
(dsd-type (dsd-type dsd)))
(when accessor-name
(multiple-value-bind (reader-designator writer-designator)
- (accessor-inline-expansion-designators dd dsd)
+ (slot-accessor-inline-expansion-designators dd dsd)
(sb!xc:proclaim `(ftype (function (,dtype) ,dsd-type)
,accessor-name))
- (setf (info :function
- :inline-expansion-designator
- accessor-name)
+ (setf (info :function :inline-expansion-designator accessor-name)
reader-designator
(info :function :inlinep accessor-name)
:inline)
(info :function :inlinep setf-accessor-name)
:inline))))))))
- #+sb-xc (/show0 "leaving %COMPILER-DEFSTRUCT")
(values))
\f
;;;; redefinition stuff
(let ((os (find name oslots :key #'dsd-name))
(ns (find name nslots :key #'dsd-name)))
(unless (subtypep (dsd-type ns) (dsd-type os))
- (/noshow "found retyped slots" ns os (dsd-type ns) (dsd-type os))
(retyped name))
(unless (and (= (dsd-index os) (dsd-index ns))
(eq (dsd-raw-type os) (dsd-raw-type ns)))
;;; be used.
(defun %redefine-defstruct (class old-layout new-layout)
(declare (type sb!xc:class class) (type layout old-layout new-layout))
- #+sb-xc (/show0 "entering %REDEFINE-DEFSTRUCT")
(let ((name (class-proper-name class)))
(restart-case
(error "redefining class ~S incompatibly with the current definition"
name)
(register-layout new-layout :invalidate nil
:destruct-layout old-layout))))
- #+sb-xc (/show0 "leaving %REDEFINE-DEFSTRUCT")
(values))
;;; This is called when we are about to define a structure class. It
;;; over this type, clearing the compiler structure type info, and
;;; undefining all the associated functions.
(defun undefine-structure (class)
- #+sb-xc (/show0 "entering UNDEFINE-STRUCTURE")
(let ((info (layout-info (class-layout class))))
(when (defstruct-description-p info)
(let ((type (dd-name info)))
;; Clear out the SPECIFIER-TYPE cache so that subsequent
;; references are unknown types.
(values-specifier-type-cache-clear)))
- #+sb-xc (/show0 "leaving UNDEFINE-STRUCTURE")
(values))
\f
;;; Return a list of pairs (name . index). Used for :TYPE'd
(res)))
\f
-;;;; slot accessors for raw slots
-
-;;; Return info about how to read/write a slot in the value stored in
-;;; OBJECT. This is also used by constructors (since we can't safely
-;;; use the accessor function, since some slots are read-only). If
-;;; supplied, DATA is a variable holding the raw-data vector.
-;;;
-;;; returned values:
-;;; 1. accessor function name (SETFable)
-;;; 2. index to pass to accessor.
-;;; 3. object form to pass to accessor
-(defun slot-accessor-form (defstruct slot object &optional data)
- (let ((rtype (dsd-raw-type slot)))
- (values
- (ecase rtype
- (single-float '%raw-ref-single)
- (double-float '%raw-ref-double)
- #!+long-float
- (long-float '%raw-ref-long)
- (complex-single-float '%raw-ref-complex-single)
- (complex-double-float '%raw-ref-complex-double)
- #!+long-float
- (complex-long-float '%raw-ref-complex-long)
- (unsigned-byte 'aref)
- ((t) '%instance-ref))
- (case rtype
- #!+long-float
- (complex-long-float
- (truncate (dsd-index slot) #!+x86 6 #!+sparc 8))
- #!+long-float
- (long-float
- (truncate (dsd-index slot) #!+x86 3 #!+sparc 4))
- (double-float
- (ash (dsd-index slot) -1))
- (complex-double-float
- (ash (dsd-index slot) -2))
- (complex-single-float
- (ash (dsd-index slot) -1))
- (t
- (dsd-index slot)))
- (cond
- ((eq rtype t) object)
- (data)
- (t
- `(truly-the (simple-array (unsigned-byte 32) (*))
- (%instance-ref ,object ,(dd-raw-index defstruct))))))))
-\f
;;; These functions are called to actually make a constructor after we
;;; have processed the arglist. The correct variant (according to the
;;; DD-TYPE) should be called. The function is defined with the
;;; various weird places, whereas STRUCTURE structures have
;;; a LAYOUT slot.
;;; * We really want to use LIST to make list structures, instead of
-;;; MAKE-LIST/(SETF ELT).
+;;; MAKE-LIST/(SETF ELT). (We can't in general use VECTOR in an
+;;; analogous way, since VECTOR makes a SIMPLE-VECTOR and vector-typed
+;;; structures can have arbitrary subtypes of VECTOR, not necessarily
+;;; SIMPLE-VECTOR.)
;;; * STRUCTURE structures can have raw slots that must also be
-;;; allocated and indirectly referenced. We use SLOT-ACCESSOR-FORM
-;;; to compute how to set the slots, which deals with raw slots.
+;;; allocated and indirectly referenced.
(defun create-vector-constructor (dd cons-name arglist vars types values)
(let ((temp (gensym))
(etype (dd-element-type dd)))
vars types))
(list ,@vals))))
(defun create-structure-constructor (dd cons-name arglist vars types values)
- (let* ((temp (gensym))
- (raw-index (dd-raw-index dd))
- (n-raw-data (when raw-index (gensym))))
+ (let* ((instance (gensym "INSTANCE"))
+ (raw-index (dd-raw-index dd)))
`(defun ,cons-name ,arglist
- (declare ,@(mapcar #'(lambda (var type) `(type ,type ,var))
+ (declare ,@(mapcar (lambda (var type) `(type ,type ,var))
vars types))
- (let ((,temp (truly-the ,(dd-name dd)
- (%make-instance ,(dd-length dd))))
- ,@(when n-raw-data
- `((,n-raw-data
- (make-array ,(dd-raw-length dd)
- :element-type '(unsigned-byte 32))))))
- (setf (%instance-layout ,temp)
- (%delayed-get-compiler-layout ,(dd-name dd)))
- ,@(when n-raw-data
- `((setf (%instance-ref ,temp ,raw-index) ,n-raw-data)))
+ (let ((,instance (truly-the ,(dd-name dd)
+ (%make-instance-with-layout
+ (%delayed-get-compiler-layout ,(dd-name dd))))))
+ (declare (optimize (safety 0))) ; Suppress redundant slot type checks.
+ ,@(when raw-index
+ `((setf (%instance-ref ,instance ,raw-index)
+ (make-array ,(dd-raw-length dd)
+ :element-type '(unsigned-byte 32)))))
,@(mapcar (lambda (dsd value)
- (multiple-value-bind (accessor index data)
- (slot-accessor-form dd dsd temp n-raw-data)
- `(setf (,accessor ,data ,index) ,value)))
+ ;; (Note that we can't in general use the
+ ;; ordinary named slot setter function here
+ ;; because the slot might be :READ-ONLY, so we
+ ;; whip up new LAMBDA representations of slot
+ ;; setters for the occasion.)
+ `(,(slot-setter-lambda-form dd dsd) ,value ,instance))
(dd-slots dd)
values)
- ,temp))))
+ ,instance))))
;;; Create a default (non-BOA) keyword constructor.
(defun create-keyword-constructor (defstruct creator)
(dolist (boa boas)
(res (create-boa-constructor defstruct boa creator)))
- `((/show0 "beginning CONSTRUCTOR-DEFINITIONS forms")
- ,@(res)
- (/show0 "done with CONSTRUCTOR-DEFINITIONS forms")))))
+ (res))))
\f
;;;; instances with ALTERNATE-METACLASS
;;;;
(declare (type symbol predicate))
(declare (type (member structure funcallable-structure) dd-type))
- (/show "entering !DEFSTRUCT-WITH-ALTERNATE-METACLASS expander" class-name)
(let* ((dd (make-dd-with-alternate-metaclass
:class-name class-name
:slot-names slot-names
(values `(%make-funcallable-instance ,dd-length
,delayed-layout-form)
'%funcallable-instance-info)))
- (/show dd raw-maker-form raw-reffer-operator)
`(progn
(eval-when (:compile-toplevel :load-toplevel :execute)
;;; special enough (and simple enough) that we just build it by hand
;;; instead of trying to generalize the ordinary DEFSTRUCT code.
(defun !set-up-structure-object-class ()
- (/show0 "entering !SET-UP-STRUCTURE-OBJECT-CLASS")
(let ((dd (make-defstruct-description 'structure-object)))
(setf
;; Note: This has an ALTERNATE-METACLASS only because of blind
(dd-slots dd) nil
(dd-length dd) 1
(dd-type dd) 'structure)
- (/show0 "about to %COMPILER-SET-UP-LAYOUT")
- (%compiler-set-up-layout dd))
- (/show0 "leaving !SET-UP-STRUCTURE-OBJECT-CLASS"))
+ (%compiler-set-up-layout dd)))
(!set-up-structure-object-class)
;;; early structure predeclarations: Set up DD and LAYOUT for ordinary
projects / sbcl.git / blobdiff