Add defknowns for TWO-ARG-CHAR-* functions.

[sbcl.git] / src / compiler / fndb.lisp

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 9f43517..3578f2f 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -76,17 +76,22 @@
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))
 (defknown (equal equalp) (t t) boolean (foldable flushable recursive))
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))
 (defknown (equal equalp) (t t) boolean (foldable flushable recursive))

+
+#!+(or x86 x86-64)
+(defknown fixnum-mod-p (t fixnum) boolean
+    (movable foldable flushable always-translatable))
+

 \f
 ;;;; classes
 
 (sb!xc:deftype name-for-class () t)
 \f
 ;;;; 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
 (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))

 \f
 ;;;; from the "Control Structure" chapter:
 
 \f
 ;;;; from the "Control Structure" chapter:
 

@@ -106,18 +111,14 @@
 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.
   (movable foldable flushable))
 (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)
   :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
 (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)
 (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) *)
 
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 

@@ -134,7 +135,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.
 ;;; 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))
 \f
 ;;;; from the "Macros" chapter:
 (defknown values-list (list) * (movable foldable unsafely-flushable))
 \f
 ;;;; from the "Macros" chapter:

@@ -142,7 +143,8 @@
 (defknown macro-function (symbol &optional lexenv-designator)
   (or function null)
   (flushable))
 (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)
   (values form &optional boolean))
 
 (defknown compiler-macro-function (t &optional lexenv-designator)

@@ -256,7 +258,7 @@
 (defknown expt (number number) number
   (movable foldable flushable explicit-check recursive))
 (defknown log (number &optional real) irrational
 (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
 (defknown sqrt (number) irrational
   (movable foldable flushable explicit-check))
 (defknown isqrt (unsigned-byte) unsigned-byte

@@ -314,10 +316,21 @@
 (defknown (numerator denominator) (rational) integer
   (movable foldable flushable))
 
 (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))
 
   (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
   (movable foldable flushable explicit-check))
 
 (defknown (mod rem) (real real) real
   (movable foldable flushable explicit-check))
 

@@ -359,6 +372,10 @@
 (defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (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
 (defknown (logcount integer-length) (integer) bit-index
   (movable foldable flushable explicit-check))
 ;;; FIXME: According to the ANSI spec, it's legal to use any

@@ -401,6 +418,14 @@
                  char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 
                  char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 

+(defknown (two-arg-char-equal
+           two-arg-char-not-equal
+           two-arg-char-lessp
+           two-arg-char-not-lessp
+           two-arg-char-greaterp
+           two-arg-char-not-greaterp)
+    (character character) boolean (movable foldable flushable))
+

 (defknown character (t) character (movable foldable unsafely-flushable))
 (defknown char-code (character) char-code (movable foldable flushable))
 (defknown (char-upcase char-downcase) (character) character
 (defknown character (t) character (movable foldable unsafely-flushable))
 (defknown char-code (character) char-code (movable foldable flushable))
 (defknown (char-upcase char-downcase) (character) character

@@ -433,7 +458,7 @@
 (defknown copy-seq (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))
 
 (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))
 
 (defknown reverse (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))

@@ -446,7 +471,7 @@
                                         &key
                                         (:initial-element t))
   consed-sequence
                                         &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
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence

@@ -461,10 +486,6 @@
 (defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
 (defknown %map-to-simple-vector-arity-1 (callable sequence) simple-vector
   (flushable call))
 (defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
 (defknown %map-to-simple-vector-arity-1 (callable sequence) simple-vector
   (flushable call))

-(defknown %map-to-nil-on-simple-vector (callable simple-vector) null
-  (flushable call))
-(defknown %map-to-nil-on-vector (callable vector) null (flushable call))
-(defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))

 
 (defknown map-into (sequence callable &rest sequence)
   sequence
 
 (defknown map-into (sequence callable &rest sequence)
   sequence

@@ -479,15 +500,14 @@
 (defknown (every notany notevery) (callable sequence &rest sequence) boolean
   (foldable unsafely-flushable call))
 
 (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
 (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
 
 (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)
   :result-arg 0)
   :derive-type #'result-type-first-arg
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
   :result-arg 0)

@@ -676,7 +696,7 @@
   t
   (foldable unsafely-flushable))
 
   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))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))

@@ -691,14 +711,24 @@
 (defknown %lastn/fixnum (list (and unsigned-byte fixnum)) t (foldable flushable))
 (defknown %lastn/bignum (list (and unsigned-byte bignum)) t (foldable flushable))
 
 (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
 (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))
 
 ;;; 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))
 
 (defknown copy-list (list) list (flushable))
 (defknown copy-alist (list) list (flushable))

@@ -720,31 +750,31 @@
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
 
 (defknown ldiff (list t) list (flushable))
   :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))
   :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))
 (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))
   :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))
 (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))
   :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))
 (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)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
 
 (defknown member (t list &key (:key callable) (:test callable)

@@ -757,7 +787,7 @@
 
 (defknown adjoin (t list &key (:key callable) (:test callable)
                     (:test-not callable))
 
 (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))
 
 (defknown (union intersection set-difference set-exclusive-or)
   (list list &key (:key callable) (:test callable) (:test-not callable))

@@ -775,8 +805,8 @@
   boolean
   (foldable flushable call))
 
   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))
 
 (defknown (rassoc assoc)
           (t list &key (:key callable) (:test callable) (:test-not callable))

@@ -784,8 +814,8 @@
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
           (callable list &key (:key callable)) list (foldable flushable call))
 
 (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))
 \f
 ;;;; from the "Hash Tables" chapter:
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
 \f
 ;;;; from the "Hash Tables" chapter:

@@ -798,15 +828,15 @@
         (:weakness (member nil :key :value :key-and-value :key-or-value))
         (:synchronized t))
   hash-table
         (: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)
 (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)
 (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)
 (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))
   :destroyed-constant-args (nth-constant-args 2))
 (defknown remhash (t hash-table) boolean ()
   :destroyed-constant-args (nth-constant-args 2))

@@ -822,6 +852,7 @@
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
 (defknown sxhash (t) hash (#-sb-xc-host foldable flushable))
 (defknown psxhash (t &optional t) hash (#-sb-xc-host foldable flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
 (defknown sxhash (t) hash (#-sb-xc-host foldable flushable))
 (defknown psxhash (t &optional t) hash (#-sb-xc-host foldable flushable))

+(defknown hash-table-equalp (hash-table hash-table) boolean (foldable flushable))

 \f
 ;;;; from the "Arrays" chapter
 
 \f
 ;;;; from the "Arrays" chapter
 

@@ -834,9 +865,9 @@
                       (:fill-pointer t)
                       (:displaced-to (or array null))
                       (:displaced-index-offset index))
                       (: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))
 
 (defknown aref (array &rest index) t (foldable))
 (defknown row-major-aref (array index) t (foldable))

@@ -875,13 +906,16 @@
 
 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
 
 (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))
   :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))
   :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
   :destroyed-constant-args (nth-constant-args 1))
 
 ;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS

@@ -892,7 +926,7 @@
          (:initial-element t) (:initial-contents t)
          (:fill-pointer t) (:displaced-to (or array null))
          (:displaced-index-offset index))
          (: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...
 \f
 ;;;; from the "Strings" chapter:
 ;  :derive-type 'result-type-arg1) Not even close...
 \f
 ;;;; from the "Strings" chapter:

@@ -960,10 +994,10 @@
 (defknown make-echo-stream (stream stream) stream (flushable))
 (defknown make-string-input-stream (string &optional index sequence-end)
   stream
 (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))
 (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))
   (flushable))
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))

@@ -990,7 +1024,7 @@
 
 (defknown set-macro-character (character callable &optional t (or readtable null))
   (eql t)
 
 (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))
 
 (defknown get-macro-character (character &optional (or readtable null))
   (values callable boolean) (flushable))
 

@@ -998,7 +1032,7 @@
   (eql t) ())
 (defknown set-dispatch-macro-character
   (character character callable &optional (or readtable null)) (eql t)
   (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)
   ())
 (defknown get-dispatch-macro-character
   (character character &optional (or readtable null)) (or callable null)
   ())

@@ -1090,7 +1124,8 @@
      (:lines (or unsigned-byte null))
      (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null))
      (:lines (or unsigned-byte null))
      (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null))

-     (:pprint-dispatch t))
+     (:pprint-dispatch t)
+     (:suppress-errors t))

   t
   (any explicit-check)
   :derive-type #'result-type-first-arg)
   t
   (any explicit-check)
   :derive-type #'result-type-first-arg)

@@ -1153,10 +1188,12 @@
                                    :directory :name
                                    :type :version))
   generalized-boolean
                                    :directory :name
                                    :type :version))
   generalized-boolean

-  ())
+  (recursive))
+

 (defknown pathname-match-p (pathname-designator pathname-designator)
   generalized-boolean
   ())
 (defknown pathname-match-p (pathname-designator pathname-designator)
   generalized-boolean
   ())

+

 (defknown translate-pathname (pathname-designator
                               pathname-designator
                               pathname-designator &key)
 (defknown translate-pathname (pathname-designator
                               pathname-designator
                               pathname-designator &key)

@@ -1181,7 +1218,7 @@
                        (:end sequence-end)
                        (:junk-allowed t))
   (values (or pathname null) sequence-end)
                        (:end sequence-end)
                        (:junk-allowed t))
   (values (or pathname null) sequence-end)

-  ())
+  (recursive))

 
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
 
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)

@@ -1218,6 +1255,8 @@
 (defknown pathname-version (pathname-designator)
   pathname-version (flushable))
 
 (defknown pathname-version (pathname-designator)
   pathname-version (flushable))
 

+(defknown pathname= (pathname pathname) boolean (movable foldable flushable))
+

 (defknown (namestring file-namestring directory-namestring host-namestring)
   (pathname-designator) (or simple-string null)
   (unsafely-flushable))
 (defknown (namestring file-namestring directory-namestring host-namestring)
   (pathname-designator) (or simple-string null)
   (unsafely-flushable))

@@ -1267,16 +1306,11 @@
 \f
 ;;;; from the "Conditions" chapter:
 
 \f
 ;;;; 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 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)
 (defknown warn (t &rest t) null)
 (defknown invoke-debugger (condition) nil)
 (defknown break (&optional format-control &rest t) null)

@@ -1336,7 +1370,7 @@
 
 (defknown apropos      (string-designator &optional package-designator t) (values))
 (defknown apropos-list (string-designator &optional package-designator t) list
 
 (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)
 
 (defknown get-decoded-time ()
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)

@@ -1360,7 +1394,7 @@
 (defknown (get-internal-run-time get-internal-real-time)
   () internal-time (flushable))
 
 (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
 
 ;;; Even though ANSI defines LISP-IMPLEMENTATION-TYPE and
 ;;; LISP-IMPLEMENTATION-VERSION to possibly punt and return NIL, we

@@ -1377,7 +1411,7 @@
            short-site-name long-site-name)
   () (or simple-string null) (flushable))
 
            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))
   :derive-type #'result-type-first-arg)
 
 (defknown constantly (t) function (movable flushable))

@@ -1397,6 +1431,12 @@
 \f
 ;;;; magical compiler frobs
 
 \f
 ;;;; 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))
 
 (defknown %unary-truncate/single-float (single-float) integer (movable foldable flushable))
 (defknown %unary-truncate/double-float (double-float) integer (movable foldable flushable))
 

@@ -1405,7 +1445,7 @@
 (defknown %typep (t (or type-specifier ctype)) boolean
   (movable flushable explicit-check))
 (defknown %instance-typep (t (or type-specifier ctype)) boolean
 (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)
 
 (defknown %cleanup-point () t)
 (defknown %special-bind (t t) t)

@@ -1436,7 +1476,7 @@
 
 ;; FIXME: This function does not return, but due to the implementation
 ;; of FILTER-LVAR we cannot write it here.
 
 ;; 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 sb!kernel::case-failure (t t t) nil)
 
 (defknown %odd-key-args-error () nil)

@@ -1446,23 +1486,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 (%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
 (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))
+  (foldable unsafely-flushable explicit-check always-translatable))
+(defknown data-vector-ref-with-offset (simple-array fixnum fixnum) t
+  (foldable unsafely-flushable explicit-check always-translatable))

 (defknown data-vector-set (array index t) t
 (defknown data-vector-set (array index t) t

-  (unsafe 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 data-vector-set-with-offset (array fixnum fixnum t) t
+  (explicit-check always-translatable))

 (defknown hairy-data-vector-ref (array index) t
   (foldable explicit-check))
 (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
 (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))
 (defknown %caller-frame () t (flushable))
 (defknown %caller-pc () system-area-pointer (flushable))
 (defknown %with-array-data (array index (or index null))

@@ -1471,7 +1512,7 @@
 (defknown %with-array-data/fp (array index (or index null))
   (values (simple-array * (*)) index index index)
   (foldable flushable))
 (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)
 (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)

@@ -1512,35 +1553,36 @@
   nil) ; never returns
 
 
   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 ())

 \f
 ;;;; SETF inverses
 
 \f
 ;;;; SETF inverses
 

-(defknown %aset (array &rest t) t (unsafe)
+(defknown %aset (array &rest t) t ()

   :destroyed-constant-args (nth-constant-args 1))
   :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))
   :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))
   :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))
   :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))
   :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))
   :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))
   :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))
   :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))
   :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 %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))
   :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))
 \f
 ;;;; ALIEN and call-out-to-C stuff
   :destroyed-constant-args (nth-constant-args 1))
 \f
 ;;;; ALIEN and call-out-to-C stuff

@@ -1548,7 +1590,7 @@
 ;; Used by WITH-PINNED-OBJECTS
 #!+(or x86 x86-64)
 (defknown sb!vm::touch-object (t) (values)
 ;; 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)
 
 #!+linkage-table
 (defknown foreign-symbol-dataref-sap (simple-string)

@@ -1566,7 +1608,7 @@
 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
 ;;;; 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))
 
 (defknown policy-quality (policy symbol) policy-quality
           (flushable))

@@ -1578,6 +1620,13 @@
   ())
 (defknown style-warn (t &rest t) null ())
 
   ())
 (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
 
 
 ;;;; memory barriers
 

@@ -1587,11 +1636,19 @@
 (defknown sb!vm:%write-barrier () (values) ())
 (defknown sb!vm:%data-dependency-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
 
 ;;;; 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
 (defknown %compare-and-swap-instance-ref (instance index t t) t

-    (unsafe))
+    ())

 (defknown %compare-and-swap-symbol-value (symbol t t) t
 (defknown %compare-and-swap-symbol-value (symbol t t) t

-    (unsafe unwind))
+    (unwind))
+(defknown spin-loop-hint () (values)
+    (always-translatable))