X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=1aef68dbf4ecc81dc9972f3b42fdbe7d9e64e40a;hb=0b3f5cc5fa9e6b121d232960ccd964d2eb15f695;hp=6fb5eb8eeeba9f0b9834a4a1e9b623c38b510538;hpb=06092ed641dc7126064b25c5377cbd953bb7c4c6;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 6fb5eb8..1aef68d 100644
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -80,13 +80,13 @@
 ;;;; classes
 
 (sb!xc:deftype name-for-class () t)
-(defknown classoid-name (classoid) name-for-class (flushable))
+(defknown classoid-name (classoid) symbol (flushable))
 (defknown find-classoid (name-for-class &optional t)
   (or classoid null) ())
 (defknown classoid-of (t) classoid (flushable))
 (defknown layout-of (t) layout (flushable))
 (defknown copy-structure (structure-object) structure-object
-  (flushable unsafe))
+  (flushable))
 
 ;;;; from the "Control Structure" chapter:
 
@@ -106,18 +106,14 @@
 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.
   (movable foldable flushable))
-(defknown set (symbol t) t (unsafe)
+(defknown set (symbol t) t ()
   :derive-type #'result-type-last-arg)
-(defknown fdefinition ((or symbol cons)) function (unsafe explicit-check))
+(defknown fdefinition ((or symbol cons)) function (explicit-check))
 (defknown %set-fdefinition ((or symbol cons) function) function
-  (unsafe explicit-check))
+  (explicit-check))
 (defknown makunbound (symbol) symbol)
 (defknown fmakunbound ((or symbol cons)) (or symbol cons)
-  (unsafe explicit-check))
-(defknown (get-setf-method get-setf-method-multiple-value)
-  ((or list symbol) &optional lexenv-designator)
-  (values list list list form form)
-  (flushable))
+  (explicit-check))
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 
@@ -134,7 +130,7 @@
 ;;; We let VALUES-LIST be foldable, since constant-folding will turn
 ;;; it into VALUES. VALUES is not foldable, since MV constants are
 ;;; represented by a call to VALUES.
-(defknown values (&rest t) * (movable flushable unsafe))
+(defknown values (&rest t) * (movable flushable))
 (defknown values-list (list) * (movable foldable unsafely-flushable))
 
 ;;;; from the "Macros" chapter:
@@ -142,7 +138,8 @@
 (defknown macro-function (symbol &optional lexenv-designator)
   (or function null)
   (flushable))
-(defknown (macroexpand macroexpand-1) (t &optional lexenv-designator)
+(defknown (macroexpand macroexpand-1 %macroexpand %macroexpand-1)
+    (t &optional lexenv-designator)
   (values form &optional boolean))
 
 (defknown compiler-macro-function (t &optional lexenv-designator)
@@ -256,7 +253,7 @@
 (defknown expt (number number) number
   (movable foldable flushable explicit-check recursive))
 (defknown log (number &optional real) irrational
-  (movable foldable flushable explicit-check))
+  (movable foldable flushable explicit-check recursive))
 (defknown sqrt (number) irrational
   (movable foldable flushable explicit-check))
 (defknown isqrt (unsigned-byte) unsigned-byte
@@ -314,8 +311,19 @@
 (defknown (numerator denominator) (rational) integer
   (movable foldable flushable))
 
-(defknown (floor ceiling truncate round)
+(defknown (floor ceiling round)
+  (real &optional real) (values integer real)
+  (movable foldable flushable explicit-check))
+
+(defknown truncate
   (real &optional real) (values integer real)
+  (movable foldable flushable explicit-check recursive))
+
+(defknown %multiply-high (word word) word
+    (movable foldable flushable))
+
+(defknown (%floor %ceiling)
+  (real real) (values integer real)
   (movable foldable flushable explicit-check))
 
 (defknown (mod rem) (real real) real
@@ -326,18 +334,18 @@
   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)
-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable explicit-check))
 (defknown scale-float (float integer) float
   (movable foldable unsafely-flushable explicit-check))
 (defknown float-radix (float) float-radix
-  (movable foldable flushable))
+  (movable foldable unsafely-flushable))
 (defknown float-sign (float &optional float) float
-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable explicit-check))
 (defknown (float-digits float-precision) (float) float-digits
-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable explicit-check))
 (defknown integer-decode-float (float)
-          (values integer float-int-exponent (member -1 1))
-          (movable foldable flushable explicit-check))
+    (values integer float-int-exponent (member -1 1))
+    (movable foldable unsafely-flushable explicit-check))
 
 (defknown complex (real &optional real) number
   (movable foldable flushable explicit-check))
@@ -359,6 +367,10 @@
 (defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
+#!+ash-right-vops
+(defknown %ash/right ((or word sb!vm:signed-word) (mod #.sb!vm:n-word-bits))
+    (or word sb!vm:signed-word)
+    (movable foldable flushable always-translatable))
 (defknown (logcount integer-length) (integer) bit-index
   (movable foldable flushable explicit-check))
 ;;; FIXME: According to the ANSI spec, it's legal to use any
@@ -380,8 +392,12 @@
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))
 (defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
-  (or (float 0.0) (integer 0)) ())
-(defknown make-random-state (&optional (or (member nil t) random-state))
+  (or (float 0.0) (integer 0))
+  (explicit-check))
+(defknown make-random-state (&optional
+                             (or (member nil t) random-state unsigned-byte
+                                 (simple-array (unsigned-byte 8) (*))
+                                 (simple-array (unsigned-byte 32) (*))))
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))
 
@@ -429,7 +445,7 @@
 (defknown copy-seq (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))
 
-(defknown length (sequence) index (foldable flushable))
+(defknown length (sequence) index (foldable flushable dx-safe))
 
 (defknown reverse (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))
@@ -442,7 +458,7 @@
                                         &key
                                         (:initial-element t))
   consed-sequence
-  (movable unsafe)
+  (movable)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
@@ -475,23 +491,24 @@
 (defknown (every notany notevery) (callable sequence &rest sequence) boolean
   (foldable unsafely-flushable call))
 
-;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable sequence &rest t &key (:from-end t) (:start index)
                   (:end sequence-end) (:initial-value t) (:key callable))
   t
-  (foldable flushable call unsafe))
+  (foldable flushable call))
 
 (defknown fill (sequence t &rest t &key
                          (:start index) (:end sequence-end)) sequence
-  (unsafe)
+    ()
   :derive-type #'result-type-first-arg
-  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+  :result-arg 0)
 
 (defknown replace (sequence sequence &rest t &key (:start1 index)
                    (:end1 sequence-end) (:start2 index) (:end2 sequence-end))
   sequence ()
   :derive-type #'result-type-first-arg
-  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+  :result-arg 0)
 
 (defknown remove
   (t sequence &rest t &key (:from-end t) (:test callable)
@@ -670,7 +687,7 @@
   t
   (foldable unsafely-flushable))
 
-(defknown cons (t t) cons (movable flushable unsafe))
+(defknown cons (t t) cons (movable flushable))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))
@@ -685,14 +702,24 @@
 (defknown %lastn/fixnum (list (and unsigned-byte fixnum)) t (foldable flushable))
 (defknown %lastn/bignum (list (and unsigned-byte bignum)) t (foldable flushable))
 
-(defknown list (&rest t) list (movable flushable unsafe))
-(defknown list* (t &rest t) t (movable flushable unsafe))
+(defknown list (&rest t) list (movable flushable))
+(defknown list* (t &rest t) t (movable flushable))
 (defknown make-list (index &key (:initial-element t)) list
-  (movable flushable unsafe))
+  (movable flushable))
+
+(defknown sb!impl::backq-list (&rest t) list (movable flushable))
+(defknown sb!impl::backq-list* (t &rest t) t (movable flushable))
+(defknown sb!impl::backq-append (&rest t) t (flushable))
+(defknown sb!impl::backq-nconc (&rest t) t ()
+  :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
+(defknown sb!impl::backq-cons (t t) cons (foldable movable flushable))
+(defknown sb!impl::backq-vector (list) simple-vector
+    (foldable movable flushable))
 
 ;;; All but last must be of type LIST, but there seems to be no way to
 ;;; express that in this syntax.
 (defknown append (&rest t) t (flushable))
+(defknown sb!impl::append2 (list t) t (flushable))
 
 (defknown copy-list (list) list (flushable))
 (defknown copy-alist (list) list (flushable))
@@ -714,31 +741,31 @@
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
 
 (defknown ldiff (list t) list (flushable))
-(defknown (rplaca rplacd) (cons t) list (unsafe)
+(defknown (rplaca rplacd) (cons t) list ()
   :destroyed-constant-args (nth-constant-args 1))
 
 (defknown subst (t t t &key (:key callable) (:test callable)
                    (:test-not callable))
-  t (flushable unsafe call))
+  t (flushable call))
 (defknown nsubst (t t t &key (:key callable) (:test callable)
                     (:test-not callable))
-  t (unsafe call)
+  t (call)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
 
 (defknown (subst-if subst-if-not)
           (t callable t &key (:key callable))
-  t (flushable unsafe call))
+  t (flushable call))
 (defknown (nsubst-if nsubst-if-not)
           (t callable t &key (:key callable))
-  t (unsafe call)
+  t (call)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
 
 (defknown sublis (list t &key (:key callable) (:test callable)
                        (:test-not callable))
-  t (flushable unsafe call))
+  t (flushable call))
 (defknown nsublis (list t &key (:key callable) (:test callable)
                         (:test-not callable))
-  t (flushable unsafe call)
+  t (flushable call)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
 
 (defknown member (t list &key (:key callable) (:test callable)
@@ -751,7 +778,7 @@
 
 (defknown adjoin (t list &key (:key callable) (:test callable)
                     (:test-not callable))
-  list (foldable flushable unsafe call))
+  list (foldable flushable call))
 
 (defknown (union intersection set-difference set-exclusive-or)
   (list list &key (:key callable) (:test callable) (:test-not callable))
@@ -769,8 +796,8 @@
   boolean
   (foldable flushable call))
 
-(defknown acons (t t t) list (movable flushable unsafe))
-(defknown pairlis (t t &optional t) list (flushable unsafe))
+(defknown acons (t t t) list (movable flushable))
+(defknown pairlis (t t &optional t) list (flushable))
 
 (defknown (rassoc assoc)
           (t list &key (:key callable) (:test callable) (:test-not callable))
@@ -778,8 +805,8 @@
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
           (callable list &key (:key callable)) list (foldable flushable call))
 
-(defknown (memq assq) (t list) list (foldable flushable unsafe))
-(defknown delq (t list) list (flushable unsafe)
+(defknown (memq assq) (t list) list (foldable flushable))
+(defknown delq (t list) list (flushable)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
 
 ;;;; from the "Hash Tables" chapter:
@@ -788,18 +815,19 @@
   (&key (:test callable) (:size unsigned-byte)
         (:rehash-size (or (integer 1) (float (1.0))))
         (:rehash-threshold (real 0 1))
+        (:hash-function (or null callable))
         (:weakness (member nil :key :value :key-and-value :key-or-value))
         (:synchronized t))
   hash-table
-  (flushable unsafe))
+  (flushable))
 (defknown hash-table-p (t) boolean (movable foldable flushable))
 (defknown gethash (t hash-table &optional t) (values t boolean)
-  (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
+  (flushable)) ; not FOLDABLE, since hash table contents can change
 (defknown sb!impl::gethash2 (t hash-table) (values t boolean)
-  (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
+  (flushable)) ; not FOLDABLE, since hash table contents can change
 (defknown sb!impl::gethash3 (t hash-table t) (values t boolean)
-  (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
-(defknown %puthash (t hash-table t) t (unsafe)
+  (flushable)) ; not FOLDABLE, since hash table contents can change
+(defknown %puthash (t hash-table t) t ()
   :destroyed-constant-args (nth-constant-args 2))
 (defknown remhash (t hash-table) boolean ()
   :destroyed-constant-args (nth-constant-args 2))
@@ -827,9 +855,9 @@
                       (:fill-pointer t)
                       (:displaced-to (or array null))
                       (:displaced-index-offset index))
-  array (flushable unsafe))
+  array (flushable))
 
-(defknown vector (&rest t) simple-vector (flushable unsafe))
+(defknown vector (&rest t) simple-vector (flushable))
 
 (defknown aref (array &rest index) t (foldable))
 (defknown row-major-aref (array index) t (foldable))
@@ -868,13 +896,16 @@
 
 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
-(defknown fill-pointer (vector) index (foldable unsafely-flushable))
-(defknown vector-push (t vector) (or index null) ()
+(defknown fill-pointer (complex-vector) index
+    (unsafely-flushable explicit-check))
+(defknown vector-push (t complex-vector) (or index null)
+    (explicit-check)
   :destroyed-constant-args (nth-constant-args 2))
-(defknown vector-push-extend (t vector &optional (and index (integer 1)))
-  index ()
+(defknown vector-push-extend (t complex-vector &optional (and index (integer 1))) index
+    (explicit-check)
   :destroyed-constant-args (nth-constant-args 2))
-(defknown vector-pop (vector) t ()
+(defknown vector-pop (complex-vector) t
+    (explicit-check)
   :destroyed-constant-args (nth-constant-args 1))
 
 ;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
@@ -885,7 +916,7 @@
          (:initial-element t) (:initial-contents t)
          (:fill-pointer t) (:displaced-to (or array null))
          (:displaced-index-offset index))
-  array (unsafe))
+  array ())
 ;  :derive-type 'result-type-arg1) Not even close...
 
 ;;;; from the "Strings" chapter:
@@ -953,10 +984,10 @@
 (defknown make-echo-stream (stream stream) stream (flushable))
 (defknown make-string-input-stream (string &optional index sequence-end)
   stream
-  (flushable unsafe))
+  (flushable))
 (defknown make-string-output-stream
     (&key (:element-type type-specifier))
-    stream
+    string-output-stream
   (flushable))
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
@@ -983,7 +1014,7 @@
 
 (defknown set-macro-character (character callable &optional t (or readtable null))
   (eql t)
-  (unsafe))
+  ())
 (defknown get-macro-character (character &optional (or readtable null))
   (values callable boolean) (flushable))
 
@@ -991,7 +1022,7 @@
   (eql t) ())
 (defknown set-dispatch-macro-character
   (character character callable &optional (or readtable null)) (eql t)
-  (unsafe))
+  ())
 (defknown get-dispatch-macro-character
   (character character &optional (or readtable null)) (or callable null)
   ())
@@ -1146,10 +1177,12 @@
                                    :directory :name
                                    :type :version))
   generalized-boolean
-  ())
+  (recursive))
+
 (defknown pathname-match-p (pathname-designator pathname-designator)
   generalized-boolean
   ())
+
 (defknown translate-pathname (pathname-designator
                               pathname-designator
                               pathname-designator &key)
@@ -1174,7 +1207,7 @@
                        (:end sequence-end)
                        (:junk-allowed t))
   (values (or pathname null) sequence-end)
-  ())
+  (recursive))
 
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
@@ -1229,7 +1262,7 @@
                                            :rename-and-delete :overwrite
                                            :append :supersede nil))
                        (:if-does-not-exist (member :error :create nil))
-                       (:external-format keyword))
+                       (:external-format external-format-designator))
   (or stream null))
 
 (defknown rename-file (pathname-designator filename)
@@ -1252,24 +1285,19 @@
    (:verbose t)
    (:print t)
    (:if-does-not-exist t)
-   (:external-format keyword))
+   (:external-format external-format-designator))
   t)
 
-(defknown directory (pathname-designator &key (resolve-symlinks t))
+(defknown directory (pathname-designator &key (:resolve-symlinks t))
   list ())
 
 ;;;; from the "Conditions" chapter:
 
-(defknown cell-error-name (cell-error) t)
 (defknown error (t &rest t) nil)
 (defknown cerror (format-control t &rest t) null)
 (defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
 (defknown method-combination-error (format-control &rest t) *)
 (defknown signal (t &rest t) null)
-(defknown simple-condition-format-control (condition)
-  format-control)
-(defknown simple-condition-format-arguments (condition)
-  list)
 (defknown warn (t &rest t) null)
 (defknown invoke-debugger (condition) nil)
 (defknown break (&optional format-control &rest t) null)
@@ -1286,7 +1314,9 @@
   null)
 
 ;;; and analogous SBCL extension:
+(defknown sb!impl::%failed-aver (t) nil)
 (defknown bug (t &rest t) nil) ; never returns
+
 
 ;;;; from the "Miscellaneous" Chapter:
 
@@ -1304,11 +1334,12 @@
                      (member t)))
    (:verbose t)
    (:print t)
-   (:external-format keyword)
+   (:external-format external-format-designator)
 
    ;; extensions
    (:trace-file t)
-   (:block-compile t))
+   (:block-compile t)
+   (:emit-cfasl t))
   (values (or pathname null) boolean boolean))
 
 ;; FIXME: consider making (OR CALLABLE CONS) something like
@@ -1317,10 +1348,6 @@
                        (:stream stream) (:use-labels t))
   null)
 
-(defknown fdocumentation (t symbol)
-  (or string null)
-  (flushable))
-
 (defknown describe (t &optional (or stream (member t nil))) (values))
 (defknown inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))
@@ -1330,7 +1357,7 @@
 
 (defknown apropos      (string-designator &optional package-designator t) (values))
 (defknown apropos-list (string-designator &optional package-designator t) list
-  (flushable))
+  (flushable recursive))
 
 (defknown get-decoded-time ()
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
@@ -1354,7 +1381,7 @@
 (defknown (get-internal-run-time get-internal-real-time)
   () internal-time (flushable))
 
-(defknown sleep ((or (rational 0) (float 0.0))) null)
+(defknown sleep ((real 0)) null (explicit-check))
 
 ;;; Even though ANSI defines LISP-IMPLEMENTATION-TYPE and
 ;;; LISP-IMPLEMENTATION-VERSION to possibly punt and return NIL, we
@@ -1371,7 +1398,7 @@
            short-site-name long-site-name)
   () (or simple-string null) (flushable))
 
-(defknown identity (t) t (movable foldable flushable unsafe)
+(defknown identity (t) t (movable foldable flushable)
   :derive-type #'result-type-first-arg)
 
 (defknown constantly (t) function (movable flushable))
@@ -1379,25 +1406,33 @@
 
 ;;;; miscellaneous extensions
 
+(defknown symbol-global-value (symbol) t ())
+(defknown set-symbol-global-value (symbol t) t ())
+
 (defknown get-bytes-consed () unsigned-byte (flushable))
 (defknown mask-signed-field ((integer 0 *) integer) integer
           (movable flushable foldable))
 
-;;; PCOUNTERs
-(defknown incf-pcounter (pcounter unsigned-byte) pcounter)
-(defknown pcounter->integer (pcounter) unsigned-byte)
-(defknown %incf-pcounter-or-fixnum ((or pcounter fixnum) unsigned-byte)
-  (or pcounter fixnum))
-(defknown pcounter-or-fixnum->integer ((or pcounter fixnum)) unsigned-byte)
+(defknown array-storage-vector (array) (simple-array * (*))
+    (any))
 
 ;;;; magical compiler frobs
 
+(defknown %rest-values (t t t) * (always-translatable))
+(defknown %rest-ref (t t t t) * (always-translatable))
+(defknown %rest-length (t t t) * (always-translatable))
+(defknown %rest-null (t t t t) * (always-translatable))
+(defknown %rest-true (t t t) * (always-translatable))
+
+(defknown %unary-truncate/single-float (single-float) integer (movable foldable flushable))
+(defknown %unary-truncate/double-float (double-float) integer (movable foldable flushable))
+
 ;;; We can't fold this in general because of SATISFIES. There is a
 ;;; special optimizer anyway.
 (defknown %typep (t (or type-specifier ctype)) boolean
   (movable flushable explicit-check))
 (defknown %instance-typep (t (or type-specifier ctype)) boolean
-  (movable flushable explicit-check))
+  (movable flushable explicit-check always-translatable))
 
 (defknown %cleanup-point () t)
 (defknown %special-bind (t t) t)
@@ -1428,7 +1463,8 @@
 
 ;; FIXME: This function does not return, but due to the implementation
 ;; of FILTER-LVAR we cannot write it here.
-(defknown %compile-time-type-error (t t t) *)
+(defknown %compile-time-type-error (t t t t) *)
+(defknown sb!kernel::case-failure (t t t) nil)
 
 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
@@ -1437,23 +1473,24 @@
 (defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer
   (movable foldable flushable explicit-check))
 (defknown %negate (number) number (movable foldable flushable explicit-check))
-(defknown %check-bound (array index fixnum) index (movable foldable flushable))
+(defknown %check-bound (array index fixnum) index
+  (movable foldable flushable dx-safe))
 (defknown data-vector-ref (simple-array index) t
   (foldable explicit-check always-translatable))
 (defknown data-vector-ref-with-offset (simple-array index fixnum) t
   (foldable explicit-check always-translatable))
 (defknown data-vector-set (array index t) t
-  (unsafe explicit-check always-translatable))
+  (explicit-check always-translatable))
 (defknown data-vector-set-with-offset (array index fixnum t) t
-  (unsafe explicit-check always-translatable))
+  (explicit-check always-translatable))
 (defknown hairy-data-vector-ref (array index) t
   (foldable explicit-check))
-(defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
+(defknown hairy-data-vector-set (array index t) t (explicit-check))
 (defknown hairy-data-vector-ref/check-bounds (array index) t
   (foldable explicit-check))
 (defknown hairy-data-vector-set/check-bounds (array index t)
   t
-  (unsafe explicit-check))
+  (explicit-check))
 (defknown %caller-frame () t (flushable))
 (defknown %caller-pc () system-area-pointer (flushable))
 (defknown %with-array-data (array index (or index null))
@@ -1462,7 +1499,7 @@
 (defknown %with-array-data/fp (array index (or index null))
   (values (simple-array * (*)) index index index)
   (foldable flushable))
-(defknown %set-symbol-package (symbol t) t (unsafe))
+(defknown %set-symbol-package (symbol t) t ())
 (defknown %coerce-name-to-fun ((or symbol cons)) function (flushable))
 (defknown %coerce-callable-to-fun (callable) function (flushable))
 (defknown array-bounding-indices-bad-error (t t t) nil)
@@ -1503,38 +1540,36 @@
   nil) ; never returns
 
 
-(defknown arg-count-error (t t t t t t) nil (unsafe))
+(defknown arg-count-error (t t t t t t) nil ())
 
 ;;;; SETF inverses
 
-(defknown %aset (array &rest t) t (unsafe)
+(defknown %aset (array &rest t) t ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %set-row-major-aref (array index t) t (unsafe)
+(defknown %set-row-major-aref (array index t) t ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown (%rplaca %rplacd) (cons t) t (unsafe)
+(defknown (%rplaca %rplacd) (cons t) t ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %put (symbol t t) t (unsafe))
-(defknown %setelt (sequence index t) t (unsafe)
+(defknown %put (symbol t t) t ())
+(defknown %setelt (sequence index t) t ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %svset (simple-vector index t) t (unsafe)
+(defknown %svset (simple-vector index t) t ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %bitset ((array bit) &rest index) bit (unsafe)
+(defknown %bitset ((array bit) &rest index) bit ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %sbitset ((simple-array bit) &rest index) bit (unsafe)
+(defknown %sbitset ((simple-array bit) &rest index) bit ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %charset (string index character) character (unsafe)
+(defknown %charset (string index character) character ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %scharset (simple-string index character) character (unsafe)
+(defknown %scharset (simple-string index character) character ()
   :destroyed-constant-args (nth-constant-args 1))
-(defknown %set-symbol-value (symbol t) t (unsafe))
-(defknown (setf symbol-function) (function symbol) function (unsafe))
-(defknown %set-symbol-plist (symbol list) list (unsafe))
-(defknown (setf fdocumentation) ((or string null) t symbol)
-  (or string null)
-  ())
-(defknown %setnth (unsigned-byte list t) t (unsafe)
+(defknown %set-symbol-value (symbol t) t ())
+(defknown (setf symbol-function) (function symbol) function ())
+(defknown %set-symbol-plist (symbol list) list ())
+(defknown %setnth (unsigned-byte list t) t ()
   :destroyed-constant-args (nth-constant-args 2))
-(defknown %set-fill-pointer (vector index) index (unsafe)
+(defknown %set-fill-pointer (complex-vector index) index
+    (explicit-check)
   :destroyed-constant-args (nth-constant-args 1))
 
 ;;;; ALIEN and call-out-to-C stuff
@@ -1542,7 +1577,7 @@
 ;; Used by WITH-PINNED-OBJECTS
 #!+(or x86 x86-64)
 (defknown sb!vm::touch-object (t) (values)
-    (unsafe always-translatable))
+    (always-translatable))
 
 #!+linkage-table
 (defknown foreign-symbol-dataref-sap (simple-string)
@@ -1560,7 +1595,7 @@
 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
-(defknown (setf %fun-name) (t function) t (unsafe))
+(defknown (setf %fun-name) (t function) t ())
 
 (defknown policy-quality (policy symbol) policy-quality
           (flushable))
@@ -1572,10 +1607,35 @@
   ())
 (defknown style-warn (t &rest t) null ())
 
+(defknown coerce-to-condition ((or condition symbol string function)
+                               list type-specifier symbol)
+    condition
+    (explicit-check))
+
+(defknown sc-number-or-lose (symbol) sc-number
+  (foldable))
+
+;;;; memory barriers
+
+(defknown sb!vm:%compiler-barrier () (values) ())
+(defknown sb!vm:%memory-barrier () (values) ())
+(defknown sb!vm:%read-barrier () (values) ())
+(defknown sb!vm:%write-barrier () (values) ())
+(defknown sb!vm:%data-dependency-barrier () (values) ())
+
+#!+sb-safepoint
+;;; Note: This known function does not have an out-of-line definition;
+;;; and if such a definition were needed, it would not need to "call"
+;;; itself inline, but could be a no-op, because the compiler inserts a
+;;; use of the VOP in the function prologue anyway.
+(defknown sb!kernel::gc-safepoint () (values) ())
+
 ;;;; atomic ops
 (defknown %compare-and-swap-svref (simple-vector index t t) t
-    (unsafe))
+    ())
 (defknown %compare-and-swap-instance-ref (instance index t t) t
-    (unsafe))
+    ())
 (defknown %compare-and-swap-symbol-value (symbol t t) t
-    (unsafe unwind))
+    (unwind))
+(defknown spin-loop-hint () (values)
+    (always-translatable))