X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ffop.lisp;h=02dcf617f82674656af3d8b4f61244f580d37fed;hb=11f6bc8c710bfa83e8cddbc9a389be02ae6ee7ef;hp=24e5c0af31c7eacf6afbcd80ecbd31b5da5639ab;hpb=a3706c5d9d95ebb5a14e7ab7313c5781e5c86713;p=sbcl.git

diff --git a/src/code/fop.lisp b/src/code/fop.lisp
index 24e5c0a..02dcf61 100644
--- a/src/code/fop.lisp
+++ b/src/code/fop.lisp
@@ -77,31 +77,36 @@
 ;;; of like READ-SEQUENCE specialized for files of (UNSIGNED-BYTE 8),
 ;;; with an automatic conversion from (UNSIGNED-BYTE 8) into CHARACTER
 ;;; for each element read
-(declaim (ftype (function (stream simple-string &optional index) (values))
-                read-string-as-bytes
-                #!+sb-unicode read-string-as-unsigned-byte-32))
 (defun read-string-as-bytes (stream string &optional (length (length string)))
-  (dotimes (i length)
-    (setf (aref string i)
-          (sb!xc:code-char (read-byte stream))))
-  ;; FIXME: The classic CMU CL code to do this was
-  ;;   (READ-N-BYTES FILE STRING START END).
-  ;; It was changed for SBCL because we needed a portable version for
-  ;; bootstrapping. Benchmark the non-portable version and see whether it's
-  ;; significantly better than the portable version here. If it is, then use
-  ;; it as an alternate definition, protected with #-SB-XC-HOST.
-  (values))
+  (declare (type (simple-array character (*)) string)
+           (type index length)
+           (optimize speed))
+  (with-fast-read-byte ((unsigned-byte 8) stream)
+    (dotimes (i length)
+      (setf (aref string i)
+            (sb!xc:code-char (fast-read-byte)))))
+  string)
+(defun read-base-string-as-bytes (stream string &optional (length (length string)))
+  (declare (type (simple-array base-char (*)) string)
+           (type index length)
+           (optimize speed))
+  (with-fast-read-byte ((unsigned-byte 8) stream)
+    (dotimes (i length)
+      (setf (aref string i)
+            (sb!xc:code-char (fast-read-byte)))))
+  string)
 #!+sb-unicode
 (defun read-string-as-unsigned-byte-32
     (stream string &optional (length (length string)))
+  (declare (type (simple-array character (*)) string)
+           (type index length)
+           (optimize speed))
   #+sb-xc-host (bug "READ-STRING-AS-UNSIGNED-BYTE-32 called")
-  (dotimes (i length)
-    (setf (aref string i)
-          (let ((code 0))
-            (dotimes (k 4 (sb!xc:code-char code))
-              (setf code (logior code (ash (read-byte stream)
-                                           (* k sb!vm:n-byte-bits))))))))
-  (values))
+  (with-fast-read-byte ((unsigned-byte 8) stream)
+    (dotimes (i length)
+      (setf (aref string i)
+            (sb!xc:code-char (fast-read-u-integer 4)))))
+  string)
 
 ;;;; miscellaneous fops
 
@@ -129,8 +134,8 @@
 
 (define-fop (fop-nop 0 :stackp nil))
 (define-fop (fop-pop 1 :pushp nil) (push-fop-table (pop-stack)))
-(define-fop (fop-push 2) (svref *current-fop-table* (read-word-arg)))
-(define-fop (fop-byte-push 3) (svref *current-fop-table* (read-byte-arg)))
+(define-fop (fop-push 2) (ref-fop-table (read-word-arg)))
+(define-fop (fop-byte-push 3) (ref-fop-table (read-byte-arg)))
 
 (define-fop (fop-empty-list 4) ())
 (define-fop (fop-truth 5) t)
@@ -140,7 +145,7 @@
   #+sb-xc-host ; since xc host doesn't know how to compile %PRIMITIVE
   (error "FOP-MISC-TRAP can't be defined without %PRIMITIVE.")
   #-sb-xc-host
-  (%primitive sb!c:make-other-immediate-type 0 sb!vm:unbound-marker-widetag))
+  (%primitive sb!c:make-unbound-marker))
 
 (define-cloned-fops (fop-character 68) (fop-short-character 69)
   (code-char (clone-arg)))
@@ -179,37 +184,37 @@
 
 (define-fop (fop-verify-table-size 62 :stackp nil)
   (let ((expected-index (read-word-arg)))
-    (unless (= *current-fop-table-index* expected-index)
+    (unless (= (get-fop-table-index) expected-index)
       (bug "fasl table of improper size"))))
 (define-fop (fop-verify-empty-stack 63 :stackp nil)
-  (unless (zerop (length *fop-stack*))
+  (unless (fop-stack-empty-p)
     (bug "fasl stack not empty when it should be")))
 
 ;;;; fops for loading symbols
 
-(defun fop-intern (smallp package)
-  (let ((size (if smallp
-                  (read-byte-arg)
-                  (read-word-arg))))
-    (when (> size (length *fasl-symbol-buffer*))
-      (setq *fasl-symbol-buffer* (make-string (* size 2))))
-    (let ((buffer *fasl-symbol-buffer*))
-      #+sb-xc-host
-      (read-string-as-bytes *fasl-input-stream* buffer size)
-      #-sb-xc-host
-      (progn
-        #!+sb-unicode
-        (read-string-as-unsigned-byte-32 *fasl-input-stream* buffer size)
-        #!-sb-unicode
-        (read-string-as-bytes *fasl-input-stream* buffer size))
-      (push-fop-table (without-package-locks
-                        (intern* buffer
-                                 size
-                                 package))))))
+(defun aux-fop-intern (smallp package)
+  (declare (optimize speed))
+  (let* ((size (if smallp
+                   (read-byte-arg)
+                   (read-word-arg)))
+         (buffer (make-string size)))
+    #+sb-xc-host
+    (read-string-as-bytes *fasl-input-stream* buffer size)
+    #-sb-xc-host
+    (progn
+      #!+sb-unicode
+      (read-string-as-unsigned-byte-32 *fasl-input-stream* buffer size)
+      #!-sb-unicode
+      (read-string-as-bytes *fasl-input-stream* buffer size))
+    (push-fop-table (without-package-locks
+                      (intern* buffer
+                               size
+                               package
+                               :no-copy t)))))
 
 (macrolet ((def (name code smallp package-form)
              `(define-fop (,name ,code)
-                (fop-intern ,smallp ,package-form))))
+                (aux-fop-intern ,smallp ,package-form))))
 
   (def fop-lisp-symbol-save          75 nil *cl-package*)
   (def fop-lisp-small-symbol-save    76 t   *cl-package*)
@@ -222,13 +227,13 @@
   ;; FOP-SYMBOL-IN-LAST-PACKAGE-SAVE/FOP-SMALL-SYMBOL-IN-LAST-PACKAGE-SAVE
   ;; cloned fop pair could undo some of this bloat.
   (def fop-symbol-in-package-save             8 nil
-    (svref *current-fop-table* (read-word-arg)))
+    (ref-fop-table (read-word-arg)))
   (def fop-small-symbol-in-package-save       9 t
-    (svref *current-fop-table* (read-word-arg)))
+    (ref-fop-table (read-word-arg)))
   (def fop-symbol-in-byte-package-save       10 nil
-    (svref *current-fop-table* (read-byte-arg)))
+    (ref-fop-table (read-byte-arg)))
   (def fop-small-symbol-in-byte-package-save 11 t
-    (svref *current-fop-table* (read-byte-arg))))
+    (ref-fop-table (read-byte-arg))))
 
 (define-cloned-fops (fop-uninterned-symbol-save 12)
                     (fop-uninterned-small-symbol-save 13)
@@ -250,26 +255,29 @@
     #+sb-xc-host
     (read-string-as-bytes *fasl-input-stream* package-name)
     #-sb-xc-host
-    (#!-sb-unicode read-string-as-bytes
-     #!+sb-unicode read-string-as-unsigned-byte-32
-     *fasl-input-stream* package-name)
+    (progn
+      #!-sb-unicode
+      (read-string-as-bytes *fasl-input-stream* package-name)
+      #!+sb-unicode
+      (read-string-as-unsigned-byte-32 *fasl-input-stream* package-name))
     (push-fop-table (find-undeleted-package-or-lose package-name))))
 
 ;;;; fops for loading numbers
 
 ;;; Load a signed integer LENGTH bytes long from *FASL-INPUT-STREAM*.
 (defun load-s-integer (length)
-  (declare (fixnum length))
-  ;; #+cmu (declare (optimize (inhibit-warnings 2)))
-  (do* ((index length (1- index))
-        (byte 0 (read-byte *fasl-input-stream*))
-        (result 0 (+ result (ash byte bits)))
-        (bits 0 (+ bits 8)))
-       ((= index 0)
-        (if (logbitp 7 byte)    ; look at sign bit
-            (- result (ash 1 bits))
-            result))
-    (declare (fixnum index byte bits))))
+  (declare (fixnum length)
+           (optimize speed))
+  (with-fast-read-byte ((unsigned-byte 8) *fasl-input-stream*)
+    (do* ((index length (1- index))
+          (byte 0 (fast-read-byte))
+          (result 0 (+ result (ash byte bits)))
+          (bits 0 (+ bits 8)))
+         ((= index 0)
+          (if (logbitp 7 byte)          ; look at sign bit
+              (- result (ash 1 bits))
+              result))
+      (declare (fixnum index byte bits)))))
 
 (define-cloned-fops (fop-integer 33) (fop-small-integer 34)
   (load-s-integer (clone-arg)))
@@ -314,6 +322,12 @@
     #!+long-float
     (define-float-fop fop-long-float 52 long-float)))
 
+#!+sb-simd-pack
+(define-fop (fop-simd-pack 88)
+  (with-fast-read-byte ((unsigned-byte 8) *fasl-input-stream*)
+    (%make-simd-pack (fast-read-s-integer 8)
+                     (fast-read-u-integer 8)
+                     (fast-read-u-integer 8))))
 
 ;;;; loading lists
 
@@ -356,7 +370,7 @@
 (define-cloned-fops (fop-base-string 37) (fop-small-base-string 38)
   (let* ((arg (clone-arg))
          (res (make-string arg :element-type 'base-char)))
-    (read-string-as-bytes *fasl-input-stream* res)
+    (read-base-string-as-bytes *fasl-input-stream* res)
     res))
 
 #!+sb-unicode
@@ -538,20 +552,20 @@
 ;;;; fops for fixing up circularities
 
 (define-fop (fop-rplaca 200 :pushp nil)
-  (let ((obj (svref *current-fop-table* (read-word-arg)))
+  (let ((obj (ref-fop-table (read-word-arg)))
         (idx (read-word-arg))
         (val (pop-stack)))
     (setf (car (nthcdr idx obj)) val)))
 
 (define-fop (fop-rplacd 201 :pushp nil)
-  (let ((obj (svref *current-fop-table* (read-word-arg)))
+  (let ((obj (ref-fop-table (read-word-arg)))
         (idx (read-word-arg))
         (val (pop-stack)))
     (setf (cdr (nthcdr idx obj)) val)))
 
 (define-fop (fop-svset 202 :pushp nil)
   (let* ((obi (read-word-arg))
-         (obj (svref *current-fop-table* obi))
+         (obj (ref-fop-table obi))
          (idx (read-word-arg))
          (val (pop-stack)))
     (if (%instancep obj)
@@ -559,7 +573,7 @@
         (setf (svref obj idx) val))))
 
 (define-fop (fop-structset 204 :pushp nil)
-  (setf (%instance-ref (svref *current-fop-table* (read-word-arg))
+  (setf (%instance-ref (ref-fop-table (read-word-arg))
                        (read-word-arg))
         (pop-stack)))
 
@@ -586,6 +600,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)