1.1.13: will be tagged as "sbcl-1.1.13"

[sbcl.git] / src / code / fop.lisp

diff --git a/src/code/fop.lisp b/src/code/fop.lisp
index 1161239..f7bb13b 100644 (file)
--- a/src/code/fop.lisp
+++ b/src/code/fop.lisp
@@ -411,94 +411,32 @@
                       t)
     res))
 
-(define-fop (fop-single-float-vector 84)
+(defglobal **saetp-bits-per-length**
+    (let ((array (make-array (1+ sb!vm:widetag-mask)
+                             :element-type '(unsigned-byte 8)
+                             :initial-element 255)))
+      (loop for saetp across sb!vm:*specialized-array-element-type-properties*
+            do
+            (setf (aref array (sb!vm:saetp-typecode saetp))
+                  (sb!vm:saetp-n-bits saetp)))
+      array)
+    "255 means bad entry.")
+(declaim (type (simple-array (unsigned-byte 8) (#.(1+ sb!vm:widetag-mask)))
+               **saetp-bits-per-length**))
+
+(define-fop (fop-spec-vector 43)
   (let* ((length (read-word-arg))
-         (result (make-array length :element-type 'single-float)))
-    (read-n-bytes *fasl-input-stream* result 0 (* length 4))
-    result))
-
-(define-fop (fop-double-float-vector 85)
-  (let* ((length (read-word-arg))
-         (result (make-array length :element-type 'double-float)))
-    (read-n-bytes *fasl-input-stream* result 0 (* length 8))
-    result))
-
-(define-fop (fop-complex-single-float-vector 86)
-  (let* ((length (read-word-arg))
-         (result (make-array length :element-type '(complex single-float))))
-    (read-n-bytes *fasl-input-stream* result 0 (* length 8))
-    result))
-
-(define-fop (fop-complex-double-float-vector 87)
-  (let* ((length (read-word-arg))
-         (result (make-array length :element-type '(complex double-float))))
-    (read-n-bytes *fasl-input-stream* result 0 (* length 16))
-    result))
-
-;;; CMU CL comment:
-;;;   *** NOT *** the FOP-INT-VECTOR as currently documented in rtguts.
-;;;   Size must be a directly supported I-vector element size, with no
-;;;   extra bits. This must be packed according to the local
-;;;   byte-ordering, allowing us to directly read the bits.
-(define-fop (fop-int-vector 43)
-  (let* ((len (read-word-arg))
-         (size (read-byte-arg))
-         (res (case size
-                (0 (make-array len :element-type 'nil))
-                (1 (make-array len :element-type 'bit))
-                (2 (make-array len :element-type '(unsigned-byte 2)))
-                (4 (make-array len :element-type '(unsigned-byte 4)))
-                (7 (prog1 (make-array len :element-type '(unsigned-byte 7))
-                     (setf size 8)))
-                (8 (make-array len :element-type '(unsigned-byte 8)))
-                (15 (prog1 (make-array len :element-type '(unsigned-byte 15))
-                      (setf size 16)))
-                (16 (make-array len :element-type '(unsigned-byte 16)))
-                (31 (prog1 (make-array len :element-type '(unsigned-byte 31))
-                      (setf size 32)))
-                (32 (make-array len :element-type '(unsigned-byte 32)))
-                #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-                (63 (prog1 (make-array len :element-type '(unsigned-byte 63))
-                      (setf size 64)))
-                (64 (make-array len :element-type '(unsigned-byte 64)))
-                (t (bug "losing i-vector element size: ~S" size)))))
-    (declare (type index len))
-    (read-n-bytes *fasl-input-stream*
-                  res
-                  0
-                  (ceiling (the index (* size len)) sb!vm:n-byte-bits))
-    res))
-
-;;; This is the same as FOP-INT-VECTOR, except this is for signed
-;;; SIMPLE-ARRAYs.
-(define-fop (fop-signed-int-vector 50)
-  (let* ((len (read-word-arg))
-         (size (read-byte-arg))
-         (res (case size
-                (8 (make-array len :element-type '(signed-byte 8)))
-                (16 (make-array len :element-type '(signed-byte 16)))
-                #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-                (29 (prog1 (make-array len :element-type '(unsigned-byte 29))
-                      (setf size 32)))
-                #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
-                (30 (prog1 (make-array len :element-type '(signed-byte 30))
-                      (setf size 32)))
-                (32 (make-array len :element-type '(signed-byte 32)))
-                #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-                (60 (prog1 (make-array len :element-type '(unsigned-byte 60))
-                      (setf size 64)))
-                #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-                (61 (prog1 (make-array len :element-type '(signed-byte 61))
-                      (setf size 64)))
-                #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
-                (64 (make-array len :element-type '(signed-byte 64)))
-                (t (bug "losing si-vector element size: ~S" size)))))
-    (declare (type index len))
-    (read-n-bytes *fasl-input-stream*
-                  res
-                  0
-                  (ceiling (the index (* size len)) sb!vm:n-byte-bits))
-    res))
+         (widetag (read-byte-arg))
+         (bits-per-length (aref **saetp-bits-per-length** widetag))
+         (bits (progn (aver (< bits-per-length 255))
+                      (* length bits-per-length)))
+         (bytes (ceiling bits sb!vm:n-byte-bits))
+         (words (ceiling bytes sb!vm:n-word-bytes))
+         (vector (allocate-vector widetag length words)))
+    (declare (type index length bytes words)
+             (type word bits))
+    (read-n-bytes *fasl-input-stream* vector 0 bytes)
+    vector))
 
 (define-fop (fop-eval 53)
   (if *skip-until*
@@ -600,6 +538,9 @@
 (define-fop (fop-fdefinition 60)
   (fdefinition-object (pop-stack) t))
 
+(define-fop (fop-known-fun 65)
+  (%coerce-name-to-fun (pop-stack)))
+
 (define-fop (fop-sanctify-for-execution 61)
   (let ((component (pop-stack)))
     (sb!vm:sanctify-for-execution component)