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 ab6d4a1..3578f2f 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -16,35 +16,21 @@
 ;;;; information for known functions:
 
 (defknown coerce (t type-specifier) t
 ;;;; information for known functions:
 
 (defknown coerce (t type-specifier) t

-  ;; Note:
-  ;; (1) This is not FLUSHABLE because it's defined to signal errors.
-  ;; (2) It's not worth trying to make this FOLDABLE in the
-  ;;     cross-compiler,because
-  ;;       (a) it would probably be really hard to make all the 
-  ;;           tricky issues (e.g. which specialized array types are
-  ;;           supported) match between cross-compiler and target
-  ;;           compiler, and besides
-  ;;       (b) leaving it not FOLDABLE lets us use the idiom
-  ;;              (COERCE FOO 'SOME-SPECIALIZED-ARRAY-TYPE-OR-ANOTHER)
-  ;;          as a way of delaying the generation of specialized
-  ;;          array types until runtime, which helps us keep the
-  ;;          cross-compiler's dumper relatively simple and which
-  ;;          lets us preserve distinctions which might not even exist
-  ;;           on the cross-compilation host (because ANSI doesn't
-  ;;          guarantee that specialized array types exist there).
-  ;; FIXME: It's actually not clear that COERCE on non-NUMBER types
-  ;; is FOLDABLE at all. Check this.
-  (movable #-sb-xc-host foldable)
-  :derive-type (result-type-specifier-nth-arg 2))
+    ;; Note:
+    ;; This is not FLUSHABLE because it's defined to signal errors.
+    (movable)
+  ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
+  ;; returns REAL/INTEGER, not COMPLEX.
+  )

 (defknown list-to-vector* (list type-specifier) vector)
 (defknown vector-to-vector* (vector type-specifier) vector)
 
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown list-to-vector* (list type-specifier) vector)
 (defknown vector-to-vector* (vector type-specifier) vector)
 
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.

-(defknown (upgraded-complex-part-type upgraded-array-element-type)
-         (type-specifier) type-specifier
-  (unsafely-flushable))
+(defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
+    (type-specifier &optional lexenv-designator) type-specifier
+    (unsafely-flushable))

 \f
 ;;;; from the "Predicates" chapter:
 
 \f
 ;;;; from the "Predicates" chapter:
 

@@ -54,7 +40,7 @@
 ;;; FIXNUMness) might be different between host and target. Perhaps
 ;;; this property should be protected by #-SB-XC-HOST? Perhaps we need
 ;;; 3-stage bootstrapping after all? (Ugh! It's *so* slow already!)
 ;;; FIXNUMness) might be different between host and target. Perhaps
 ;;; this property should be protected by #-SB-XC-HOST? Perhaps we need
 ;;; 3-stage bootstrapping after all? (Ugh! It's *so* slow already!)

-(defknown typep (t type-specifier) t
+(defknown typep (t type-specifier &optional lexenv-designator) t

    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
    ;; definitions, but unlike SUBTYPEP, there should be no way to make
    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
    ;; definitions, but unlike SUBTYPEP, there should be no way to make

@@ -73,7 +59,8 @@
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
    (foldable))
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
    (foldable))

-(defknown subtypep (type-specifier type-specifier) (values boolean boolean)
+(defknown subtypep (type-specifier type-specifier &optional lexenv-designator)
+  (values boolean boolean)

   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;

@@ -82,52 +69,65 @@
   (unsafely-flushable))
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
   (unsafely-flushable))
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp

-               complexp characterp stringp bit-vector-p vectorp
-               simple-vector-p simple-string-p simple-bit-vector-p arrayp
-               sb!xc:packagep functionp compiled-function-p not)
+                complexp characterp stringp bit-vector-p vectorp
+                simple-vector-p simple-string-p simple-bit-vector-p arrayp
+                sb!xc:packagep functionp compiled-function-p not)

   (t) boolean (movable foldable flushable))
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))
 (defknown (equal equalp) (t t) boolean (foldable flushable recursive))
   (t) boolean (movable foldable flushable))
 
 (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 class-name (sb!xc:class) name-for-class (flushable))
-(defknown find-class (name-for-class &optional t lexenv)
-  (or sb!xc:class null) ())
-(defknown class-of (t) sb!xc: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 layout-of (t) layout (flushable))
 (defknown copy-structure (structure-object) structure-object

-  (flushable unsafe))
+  (flushable))

 \f
 ;;;; from the "Control Structure" chapter:
 
 ;;; This is not FLUSHABLE, since it's required to signal an error if
 ;;; unbound.
 \f
 ;;;; from the "Control Structure" chapter:
 
 ;;; This is not FLUSHABLE, since it's required to signal an error if
 ;;; unbound.

-(defknown (symbol-value symbol-function) (symbol) t ())
+(defknown (symbol-value) (symbol) t ())
+;;; From CLHS, "If the symbol is globally defined as a macro or a
+;;; special operator, an object of implementation-dependent nature and
+;;; identity is returned. If the symbol is not globally defined as
+;;; either a macro or a special operator, and if the symbol is fbound,
+;;; a function object is returned".  Our objects of
+;;; implementation-dependent nature happen to be functions.
+(defknown (symbol-function) (symbol) function ())

 
 (defknown boundp (symbol) boolean (flushable))
 (defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.
   (movable foldable flushable))
 
 (defknown boundp (symbol) boolean (flushable))
 (defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
 (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)
-  (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) *)
 

-(defknown (mapcar maplist mapcan mapcon) (callable list &rest list) list
+(defknown (mapcar maplist) (callable list &rest list) list
+  (call))
+
+;;; According to CLHS the result must be a LIST, but we do not check
+;;; it.
+(defknown (mapcan mapcon) (callable list &rest list) t

   (call))
 
 (defknown (mapc mapl) (callable list &rest list) list (foldable call))
   (call))
 
 (defknown (mapc mapl) (callable list &rest list) list (foldable call))

@@ -135,18 +135,19 @@
 ;;; 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:
 

-(defknown macro-function (symbol &optional lexenv)
+(defknown macro-function (symbol &optional lexenv-designator)

   (or function null)
   (flushable))
   (or function null)
   (flushable))

-(defknown (macroexpand macroexpand-1) (t &optional lexenv)
+(defknown (macroexpand macroexpand-1 %macroexpand %macroexpand-1)
+    (t &optional lexenv-designator)

   (values form &optional boolean))
 
   (values form &optional boolean))
 

-(defknown compiler-macro-function (t &optional lexenv)
+(defknown compiler-macro-function (t &optional lexenv-designator)

   (or function null)
   (flushable))
 \f
   (or function null)
   (flushable))
 \f

@@ -157,30 +158,30 @@
 ;;;; from the "Symbols" chapter:
 
 (defknown get (symbol t &optional t) t (flushable))
 ;;;; from the "Symbols" chapter:
 
 (defknown get (symbol t &optional t) t (flushable))

+(defknown sb!impl::get2 (symbol t) t (flushable))
+(defknown sb!impl::get3 (symbol t t) t (flushable))

 (defknown remprop (symbol t) t)
 (defknown symbol-plist (symbol) list (flushable))
 (defknown getf (list t &optional t) t (foldable flushable))
 (defknown get-properties (list list) (values t t list) (foldable flushable))
 (defknown symbol-name (symbol) simple-string (movable foldable flushable))
 (defknown make-symbol (string) symbol (flushable))
 (defknown remprop (symbol t) t)
 (defknown symbol-plist (symbol) list (flushable))
 (defknown getf (list t &optional t) t (foldable flushable))
 (defknown get-properties (list list) (values t t list) (foldable flushable))
 (defknown symbol-name (symbol) simple-string (movable foldable flushable))
 (defknown make-symbol (string) symbol (flushable))

+(defknown %make-symbol (simple-string) symbol (flushable))

 (defknown copy-symbol (symbol &optional t) symbol (flushable))
 (defknown gensym (&optional (or string unsigned-byte)) symbol ())
 (defknown symbol-package (symbol) (or sb!xc:package null) (flushable))
 (defknown copy-symbol (symbol &optional t) symbol (flushable))
 (defknown gensym (&optional (or string unsigned-byte)) symbol ())
 (defknown symbol-package (symbol) (or sb!xc:package null) (flushable))

-(defknown keywordp (t) boolean (flushable))      ; If someone uninterns it...
+(defknown keywordp (t) boolean (flushable))       ; If someone uninterns it...

 \f
 ;;;; from the "Packages" chapter:
 
 \f
 ;;;; from the "Packages" chapter:
 

-(sb!xc:deftype package-designator () '(or stringable sb!xc:package))
-(sb!xc:deftype symbols () '(or list symbol))
-

 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown gentemp (&optional string package-designator) symbol)
 

-(defknown make-package (stringable &key
-                                  (:use list)
-                                  (:nicknames list)
-                                  ;; ### extensions...
-                                  (:internal-symbols index)
-                                  (:external-symbols index))
+(defknown make-package (string-designator &key
+                                          (:use list)
+                                          (:nicknames list)
+                                          ;; ### extensions...
+                                          (:internal-symbols index)
+                                          (:external-symbols index))

   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))

@@ -199,15 +200,17 @@
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))

-(defknown (export import) (symbols &optional package-designator) (eql t))
+(defknown (export import) (symbols-designator &optional package-designator)
+  (eql t))

 (defknown unintern (symbol &optional package-designator) boolean)
 (defknown unintern (symbol &optional package-designator) boolean)

-(defknown unexport (symbols &optional package-designator) (eql t))
-(defknown shadowing-import (symbols &optional package-designator) (eql t))
-(defknown shadow ((or symbol string list) &optional package-designator)
+(defknown unexport (symbols-designator &optional package-designator) (eql t))
+(defknown shadowing-import (symbols-designator &optional package-designator)
+  (eql t))
+(defknown shadow ((or symbol character string list) &optional package-designator)

   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))
   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))

-(defknown find-all-symbols (stringable) list (flushable))
+(defknown find-all-symbols (string-designator) list (flushable))

 \f
 ;;;; from the "Numbers" chapter:
 
 \f
 ;;;; from the "Numbers" chapter:
 

@@ -230,7 +233,7 @@
 (defknown * (&rest number) number
   (movable foldable flushable explicit-check))
 (defknown / (number &rest number) number
 (defknown * (&rest number) number
   (movable foldable flushable explicit-check))
 (defknown / (number &rest number) number

-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable explicit-check))

 (defknown (1+ 1-) (number) number
   (movable foldable flushable explicit-check))
 
 (defknown (1+ 1-) (number) number
   (movable foldable flushable explicit-check))
 

@@ -255,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

@@ -313,30 +316,41 @@
 (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))
+
+(defknown truncate

   (real &optional real) (values integer real)
   (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 (ffloor fceiling fround ftruncate)
   (movable foldable flushable explicit-check))
 
 (defknown (mod rem) (real real) real
   (movable foldable flushable explicit-check))
 
 (defknown (ffloor fceiling fround ftruncate)

-  (real &optional real) (values float float)
+  (real &optional real) (values float real)

   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)
   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)

-  (movable foldable flushable explicit-check))
-(defknown scale-float (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
 (defknown float-radix (float) float-radix

-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable))

 (defknown float-sign (float &optional float) float
 (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
 (defknown (float-digits float-precision) (float) float-digits

-  (movable foldable flushable explicit-check))
+  (movable foldable unsafely-flushable explicit-check))

 (defknown integer-decode-float (float)
 (defknown integer-decode-float (float)

-         (values integer float-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))
 
 (defknown complex (real &optional real) number
   (movable foldable flushable explicit-check))

@@ -347,7 +361,7 @@
   (movable foldable flushable explicit-check))
 
 (defknown (lognand lognor logandc1 logandc2 logorc1 logorc2)
   (movable foldable flushable explicit-check))
 
 (defknown (lognand lognor logandc1 logandc2 logorc1 logorc2)

-         (integer integer) integer
+          (integer integer) integer

   (movable foldable flushable explicit-check))
 
 (defknown boole (boole-code integer integer) integer
   (movable foldable flushable explicit-check))
 
 (defknown boole (boole-code integer integer) integer

@@ -355,9 +369,13 @@
 
 (defknown lognot (integer) integer (movable foldable flushable explicit-check))
 (defknown logtest (integer integer) boolean (movable foldable flushable))
 
 (defknown lognot (integer) integer (movable foldable flushable explicit-check))
 (defknown logtest (integer integer) boolean (movable foldable flushable))

-(defknown logbitp (bit-index integer) boolean (movable foldable flushable))
+(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))

 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (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

@@ -378,35 +396,48 @@
   (movable foldable flushable))
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))
   (movable foldable flushable))
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))

-(defknown random ((real (0)) &optional random-state) (real 0) ())
-(defknown make-random-state (&optional (or (member nil t) random-state))
+(defknown random ((or (float (0.0)) (integer 1)) &optional 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))
 \f
 ;;;; from the "Characters" chapter:
 (defknown (standard-char-p graphic-char-p alpha-char-p
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))
 \f
 ;;;; from the "Characters" chapter:
 (defknown (standard-char-p graphic-char-p alpha-char-p

-                          upper-case-p lower-case-p both-case-p alphanumericp)
+                           upper-case-p lower-case-p both-case-p alphanumericp)

   (character) boolean (movable foldable flushable))
 
   (character) boolean (movable foldable flushable))
 

-(defknown digit-char-p (character &optional unsigned-byte)
+(defknown digit-char-p (character &optional (integer 2 36))

   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal

-                char-lessp char-greaterp char-not-greaterp char-not-lessp)
+                 char-lessp char-greaterp char-not-greaterp char-not-lessp)

   (character &rest character) boolean (movable foldable flushable))
 
   (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
   (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
   (movable foldable flushable))

-(defknown digit-char (integer &optional integer)
+(defknown digit-char (unsigned-byte &optional (integer 2 36))

   (or character null) (movable foldable flushable))
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)
   (movable foldable flushable))
   (or character null) (movable foldable flushable))
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)
   (movable foldable flushable))

-(defknown name-char (stringable) (or character null)
+(defknown name-char (string-designator) (or character null)

   (movable foldable flushable))
   (movable foldable flushable))

-(defknown code-char (char-code) base-char
+(defknown code-char (char-code) character

   ;; By suppressing constant folding on CODE-CHAR when the
   ;; cross-compiler is running in the cross-compilation host vanilla
   ;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until
   ;; By suppressing constant folding on CODE-CHAR when the
   ;; cross-compiler is running in the cross-compilation host vanilla
   ;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until

@@ -427,24 +458,25 @@
 (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))
 

-(defknown nreverse (sequence) sequence ()
-  :derive-type #'result-type-first-arg)
+(defknown nreverse (sequence) sequence (important-result)
+  :derive-type #'result-type-first-arg
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 (defknown make-sequence (type-specifier index
 
 (defknown make-sequence (type-specifier index

-                                       &key
-                                       (:initial-element t))
+                                        &key
+                                        (:initial-element t))

   consed-sequence
   consed-sequence

-  (movable unsafe)
-  :derive-type (result-type-specifier-nth-arg 1))
+  (movable)
+  :derive-type (creation-result-type-specifier-nth-arg 1))

 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   ()
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   ()

-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))

 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence

@@ -454,10 +486,12 @@
 (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
+  (call)
+  :derive-type #'result-type-first-arg
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t
 
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t

@@ -466,34 +500,27 @@
 (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
-                 &key
-                 (:from-end t)
-                 (:start index)
-                 (:end sequence-end)
-                 (:initial-value t)
-                 (:key callable))
+(defknown reduce (callable sequence &rest t &key (:from-end t) (:start index)
+                  (:end sequence-end) (:initial-value t) (:key callable))

   t
   t

-  (foldable flushable call unsafe))
+  (foldable flushable call))

 
 

-(defknown fill (sequence t &key (:start index) (:end sequence-end)) sequence
-  (unsafe)
-  :derive-type #'result-type-first-arg)
+(defknown fill (sequence t &rest t &key
+                         (:start index) (:end sequence-end)) sequence
+    ()
+  :derive-type #'result-type-first-arg
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+  :result-arg 0)

 
 

-(defknown replace (sequence
-                  sequence
-                  &key
-                  (:start1 index)
-                  (:end1 sequence-end)
-                  (:start2 index)
-                  (:end2 sequence-end))
+(defknown replace (sequence sequence &rest t &key (:start1 index)
+                   (:end1 sequence-end) (:start2 index) (:end2 sequence-end))

   sequence ()
   sequence ()

-  :derive-type #'result-type-first-arg)
+  :derive-type #'result-type-first-arg
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+  :result-arg 0)

 
 (defknown remove
 
 (defknown remove

-  (t sequence &key (:from-end t) (:test callable)
+  (t sequence &rest t &key (:from-end t) (:test callable)

      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   consed-sequence
      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   consed-sequence

@@ -501,7 +528,7 @@
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown substitute
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown substitute

-  (t t sequence &key (:from-end t) (:test callable)
+  (t t sequence &rest t &key (:from-end t) (:test callable)

      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   consed-sequence
      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   consed-sequence

@@ -509,130 +536,144 @@
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (remove-if remove-if-not)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (remove-if remove-if-not)

-  (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:count sequence-count) (:key callable))
+  (callable sequence &rest t &key (:from-end t) (:start index)
+            (:end sequence-end) (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (substitute-if substitute-if-not)
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (substitute-if substitute-if-not)

-  (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-     (:count sequence-count) (:key callable))
+  (t callable sequence &rest t &key (:from-end t) (:start index)
+     (:end sequence-end) (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown delete
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown delete

-  (t sequence &key (:from-end t) (:test callable)
+  (t sequence &rest t &key (:from-end t) (:test callable)

      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   sequence
      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   sequence

-  (flushable call)
-  :derive-type (sequence-result-nth-arg 2))
+  (flushable call important-result)
+  :derive-type (sequence-result-nth-arg 2)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))

 
 (defknown nsubstitute
 
 (defknown nsubstitute

-  (t t sequence &key (:from-end t) (:test callable)
+  (t t sequence &rest t &key (:from-end t) (:test callable)

      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   sequence
   (flushable call)
      (:test-not callable) (:start index) (:end sequence-end)
      (:count sequence-count) (:key callable))
   sequence
   (flushable call)

-  :derive-type (sequence-result-nth-arg 3))
+  :derive-type (sequence-result-nth-arg 3)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))

 
 (defknown (delete-if delete-if-not)
 
 (defknown (delete-if delete-if-not)

-  (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:count sequence-count) (:key callable))
+  (callable sequence &rest t &key (:from-end t) (:start index)
+            (:end sequence-end) (:count sequence-count) (:key callable))

   sequence
   sequence

-  (flushable call)
-  :derive-type (sequence-result-nth-arg 2))
+  (flushable call important-result)
+  :derive-type (sequence-result-nth-arg 2)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))

 
 (defknown (nsubstitute-if nsubstitute-if-not)
 
 (defknown (nsubstitute-if nsubstitute-if-not)

-  (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-     (:count sequence-count) (:key callable))
+  (t callable sequence &rest t &key (:from-end t) (:start index)
+     (:end sequence-end) (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   sequence
   (flushable call)

-  :derive-type (sequence-result-nth-arg 3))
+  :derive-type (sequence-result-nth-arg 3)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))

 
 (defknown remove-duplicates
 
 (defknown remove-duplicates

-  (sequence &key (:test callable) (:test-not callable) (:start index)
-           (:from-end t) (:end sequence-end) (:key callable))
+  (sequence &rest t &key (:test callable) (:test-not callable) (:start index)
+            (:from-end t) (:end sequence-end) (:key callable))

   consed-sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   consed-sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates

-  (sequence &key (:test callable) (:test-not callable) (:start index)
-           (:from-end t) (:end sequence-end) (:key callable))
+  (sequence &rest t &key (:test callable) (:test-not callable) (:start index)
+            (:from-end t) (:end sequence-end) (:key callable))

   sequence
   sequence

-  (unsafely-flushable call)
-  :derive-type (sequence-result-nth-arg 1))
+  (unsafely-flushable call important-result)
+  :derive-type (sequence-result-nth-arg 1)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 

-(defknown find (t sequence &key (:test callable) (:test-not callable)
-                 (:start index) (:from-end t) (:end sequence-end)
-                 (:key callable))
+(defknown find (t sequence &rest t &key (:test callable)
+                (:test-not callable) (:start index) (:from-end t)
+                (:end sequence-end) (:key callable))

   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)
   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)

-  (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+  (callable sequence &rest t &key (:from-end t) (:start index)
+   (:end sequence-end) (:key callable))

   t
   (foldable flushable call))
 
   t
   (foldable flushable call))
 

-(defknown position (t sequence &key (:test callable) (:test-not callable)
-                     (:start index) (:from-end t) (:end sequence-end)
-                     (:key callable))
+(defknown position (t sequence &rest t &key (:test callable)
+                    (:test-not callable) (:start index) (:from-end t)
+                    (:end sequence-end) (:key callable))

   (or index null)
   (foldable flushable call))
 
 (defknown (position-if position-if-not)
   (or index null)
   (foldable flushable call))
 
 (defknown (position-if position-if-not)

-  (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+  (callable sequence &rest t &key (:from-end t) (:start index)
+   (:end sequence-end) (:key callable))

   (or index null)
   (foldable flushable call))
 
   (or index null)
   (foldable flushable call))
 

-(defknown count (t sequence &key (:test callable) (:test-not callable)
-                     (:start index) (:from-end t) (:end sequence-end)
-                     (:key callable))
+(defknown count (t sequence &rest t &key
+                   (:test callable) (:test-not callable) (:start index)
+                   (:from-end t) (:end sequence-end) (:key callable))

   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)
   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)

-  (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
-           (:key callable))
+  (callable sequence &rest t &key
+            (:from-end t) (:start index) (:end sequence-end) (:key callable))

   index
   (foldable flushable call))
 
 (defknown (mismatch search)
   index
   (foldable flushable call))
 
 (defknown (mismatch search)

-  (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
-           (:start1 index) (:end1 sequence-end)
-           (:start2 index) (:end2 sequence-end)
-           (:key callable))
+  (sequence sequence &rest t &key (:from-end t) (:test callable)
+   (:test-not callable) (:start1 index) (:end1 sequence-end)
+   (:start2 index) (:end2 sequence-end) (:key callable))

   (or index null)
   (foldable flushable call))
 
 ;;; not FLUSHABLE, since vector sort guaranteed in-place...
   (or index null)
   (foldable flushable call))
 
 ;;; not FLUSHABLE, since vector sort guaranteed in-place...

-(defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
+(defknown (stable-sort sort) (sequence callable &rest t &key (:key callable))
+  sequence

   (call)
   (call)

-  :derive-type (sequence-result-nth-arg 1))
+  :derive-type (sequence-result-nth-arg 1)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+(defknown sb!impl::stable-sort-list (list function function) list
+  (call important-result)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+(defknown sb!impl::sort-vector (vector index index function (or function null))
+  * ; SORT-VECTOR works through side-effect
+  (call)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 (defknown merge (type-specifier sequence sequence callable
 
 (defknown merge (type-specifier sequence sequence callable

-                               &key (:key callable))
+                                &key (:key callable))

   sequence
   sequence

-  (call)
-  :derive-type (result-type-specifier-nth-arg 1))
+  (call important-result)
+  :derive-type (creation-result-type-specifier-nth-arg 1)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 2 3))

 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream

-                                 &key
-                                 (:start index)
-                                 (:end sequence-end))
+                                  &key
+                                  (:start index)
+                                  (:end sequence-end))

   (index)
   ())
 
 (defknown write-sequence (sequence stream
   (index)
   ())
 
 (defknown write-sequence (sequence stream

-                                  &key
-                                  (:start index)
-                                  (:end sequence-end))
+                                   &key
+                                   (:start index)
+                                   (:end sequence-end))

   sequence
   ()
   :derive-type (sequence-result-nth-arg 1))
   sequence
   ()
   :derive-type (sequence-result-nth-arg 1))

@@ -643,6 +684,9 @@
   t
   (foldable flushable))
 
   t
   (foldable flushable))
 

+;; Correct argument type restrictions for these functions are
+;; complicated, so we just declare them to accept LISTs and suppress
+;; flushing is safe code.

 (defknown (caar cadr cdar cddr
                 caaar caadr cadar caddr cdaar cdadr cddar cdddr
                 caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
 (defknown (caar cadr cdar cddr
                 caaar caadr cadar caddr cdaar cdadr cddar cdddr
                 caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr

@@ -652,23 +696,39 @@
   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))

-(defknown endp (t) boolean (foldable unsafely-flushable movable))
+(defknown endp (list) boolean (foldable flushable movable))

 (defknown list-length (list) (or index null) (foldable unsafely-flushable))
 (defknown list-length (list) (or index null) (foldable unsafely-flushable))

-(defknown nth (index list) t (foldable flushable))
-(defknown nthcdr (index list) t (foldable unsafely-flushable))
-(defknown last (list &optional index) list (foldable flushable))
-(defknown list (&rest t) list (movable flushable unsafe))
-(defknown list* (t &rest t) t (movable flushable unsafe))
+(defknown nth (unsigned-byte list) t (foldable flushable))
+(defknown nthcdr (unsigned-byte list) t (foldable unsafely-flushable))
+
+(defknown last (list &optional unsigned-byte) t (foldable flushable))
+(defknown %last0 (list) t (foldable flushable))
+(defknown %last1 (list) 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))
+(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))

@@ -678,28 +738,47 @@
 ;;; All but last must be of type LIST, but there seems to be no way to
 ;;; express that in this syntax. The result must be LIST, but we do
 ;;; not check it now :-).
 ;;; All but last must be of type LIST, but there seems to be no way to
 ;;; express that in this syntax. The result must be LIST, but we do
 ;;; not check it now :-).

-(defknown nconc (&rest t) t ())
-
-(defknown nreconc (list t) list ())
-(defknown butlast (list &optional index) list (flushable))
-(defknown nbutlast (list &optional index) list ())
-(defknown ldiff (list t) list (flushable))
-(defknown (rplaca rplacd) (cons t) list (unsafe))
-
-(defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
-                           (:test-not callable))
-  list (flushable unsafe call))
+(defknown nconc (&rest t) t ()
+  :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
+(defknown sb!impl::nconc2 (list t) t ()
+  :destroyed-constant-args (remove-non-constants-and-nils #'butlast))

 
 

-(defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
-         (t t t &key (:key callable))
-  list (flushable unsafe call))
+(defknown nreconc (list t) t (important-result)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+(defknown butlast (list &optional unsigned-byte) list (flushable))
+(defknown nbutlast (list &optional unsigned-byte) list ()
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 

-(defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
-                                (:test-not callable))
-  list (flushable unsafe call))
+(defknown ldiff (list t) list (flushable))
+(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 call))
+(defknown nsubst (t t t &key (:key callable) (:test callable)
+                    (:test-not callable))
+  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 call))
+(defknown (nsubst-if nsubst-if-not)
+          (t callable t &key (:key callable))
+  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 call))
+(defknown nsublis (list t &key (:key callable) (:test callable)
+                        (:test-not callable))
+  t (flushable call)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))

 
 (defknown member (t list &key (:key callable) (:test callable)
 
 (defknown member (t list &key (:key callable) (:test callable)

-                   (:test-not callable))
+                    (:test-not callable))

   list (foldable flushable call))
 (defknown (member-if member-if-not) (callable list &key (:key callable))
   list (foldable flushable call))
   list (foldable flushable call))
 (defknown (member-if member-if-not) (callable list &key (:key callable))
   list (foldable flushable call))

@@ -707,8 +786,8 @@
 (defknown tailp (t list) boolean (foldable flushable))
 
 (defknown adjoin (t list &key (:key callable) (:test callable)
 (defknown tailp (t list) boolean (foldable flushable))
 
 (defknown adjoin (t list &key (:key callable) (:test callable)

-                   (:test-not callable))
-  list (foldable flushable unsafe call))
+                    (:test-not callable))
+  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))

@@ -718,24 +797,26 @@
 (defknown (nunion nintersection nset-difference nset-exclusive-or)
   (list list &key (:key callable) (:test callable) (:test-not callable))
   list
 (defknown (nunion nintersection nset-difference nset-exclusive-or)
   (list list &key (:key callable) (:test callable) (:test-not callable))
   list

-  (foldable flushable call))
+  (foldable flushable call important-result)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1 2))

 
 (defknown subsetp
   (list list &key (:key callable) (:test callable) (:test-not callable))
   boolean
   (foldable flushable call))
 
 
 (defknown subsetp
   (list list &key (:key callable) (:test callable) (:test-not callable))
   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)
 
 (defknown (rassoc assoc)

-         (t list &key (:key callable) (:test callable) (:test-not callable))
+          (t list &key (:key callable) (:test callable) (:test-not callable))

   list (foldable flushable call))
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
   list (foldable flushable call))
 (defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)

-         (callable list &key (:key callable)) list (foldable flushable call))
+          (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:
 
 \f
 ;;;; from the "Hash Tables" chapter:
 

@@ -743,43 +824,53 @@
   (&key (:test callable) (:size unsigned-byte)
         (:rehash-size (or (integer 1) (float (1.0))))
         (:rehash-threshold (real 0 1))
   (&key (:test callable) (:size unsigned-byte)
         (:rehash-size (or (integer 1) (float (1.0))))
         (:rehash-threshold (real 0 1))

-        (:weak-p t))
+        (:hash-function (or null callable))
+        (:weakness (member nil :key :value :key-and-value :key-or-value))
+        (:synchronized t))

   hash-table
   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
-(defknown %puthash (t hash-table t) t (unsafe))
-(defknown remhash (t hash-table) boolean ())
+  (flushable)) ; not FOLDABLE, since hash table contents can change
+(defknown sb!impl::gethash2 (t hash-table) (values t boolean)
+  (flushable)) ; not FOLDABLE, since hash table contents can change
+(defknown sb!impl::gethash3 (t hash-table t) (values t boolean)
+  (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))

 (defknown maphash (callable hash-table) null (flushable call))
 (defknown maphash (callable hash-table) null (flushable call))

-(defknown clrhash (hash-table) hash-table ())
+(defknown clrhash (hash-table) hash-table ()
+  :destroyed-constant-args (nth-constant-args 2))

 (defknown hash-table-count (hash-table) index (flushable))
 (defknown hash-table-count (hash-table) index (flushable))

-(defknown hash-table-rehash-size (hash-table) (or (integer 1) (float (1.0)))
+(defknown hash-table-rehash-size (hash-table) (or index (single-float (1.0)))

   (foldable flushable))
   (foldable flushable))

-(defknown hash-table-rehash-threshold (hash-table) (real 0 1)
+(defknown hash-table-rehash-threshold (hash-table) (single-float (0.0) 1.0)

   (foldable flushable))
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
   (foldable flushable))
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))

-(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
-  (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
 
 (defknown make-array ((or index list)
 \f
 ;;;; from the "Arrays" chapter
 
 (defknown make-array ((or index list)

-                     &key
-                     (:element-type type-specifier)
-                     (:initial-element t)
-                     (:initial-contents t)
-                     (:adjustable t)
-                     (:fill-pointer t)
-                     (:displaced-to (or array null))
-                     (:displaced-index-offset index))
-  array (flushable unsafe))
+                      &key
+                      (:element-type type-specifier)
+                      (:initial-element t)
+                      (:initial-contents t)
+                      (:adjustable t)
+                      (:fill-pointer t)
+                      (:displaced-to (or array null))
+                      (:displaced-index-offset index))
+  array (flushable))

 
 

-(defknown vector (&rest t) simple-vector (flushable unsafe))
+(defknown vector (&rest t) simple-vector (flushable))

 
 

-(defknown aref (array &rest index) t (foldable flushable))
-(defknown row-major-aref (array index) t (foldable flushable))
+(defknown aref (array &rest index) t (foldable))
+(defknown row-major-aref (array index) t (foldable))

 
 (defknown array-element-type (array)
   type-specifier
 
 (defknown array-element-type (array)
   type-specifier

@@ -787,7 +878,7 @@
 (defknown array-rank (array) array-rank (foldable flushable))
 (defknown array-dimension (array array-rank) index (foldable flushable))
 (defknown array-dimensions (array) list (foldable flushable))
 (defknown array-rank (array) array-rank (foldable flushable))
 (defknown array-dimension (array array-rank) index (foldable flushable))
 (defknown array-dimensions (array) list (foldable flushable))

-(defknown array-in-bounds-p (array &rest index) boolean (foldable flushable))
+(defknown array-in-bounds-p (array &rest integer) boolean (foldable flushable))

 (defknown array-row-major-index (array &rest index) array-total-size
   (foldable flushable))
 (defknown array-total-size (array) array-total-size (foldable flushable))
 (defknown array-row-major-index (array &rest index) array-total-size
   (foldable flushable))
 (defknown array-total-size (array) array-total-size (foldable flushable))

@@ -797,31 +888,45 @@
 (defknown bit ((array bit) &rest index) bit (foldable flushable))
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 
 (defknown bit ((array bit) &rest index) bit (foldable flushable))
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 

+;;; FIXME: :DESTROYED-CONSTANT-ARGS for these is complicated.

 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2

-                  bit-orc1 bit-orc2)
-  ((array bit) (array bit) &optional (or (array bit) (member t)))
+                   bit-orc1 bit-orc2)
+  ((array bit) (array bit) &optional (or (array bit) (member t nil)))

   (array bit)
   (array bit)

-  (foldable)
+  ()

   #|:derive-type #'result-type-last-arg|#)
 
   #|:derive-type #'result-type-last-arg|#)
 

-(defknown bit-not ((array bit) &optional (or (array bit) (member t)))
+(defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))

   (array bit)
   (array bit)

-  (foldable)
+  ()

   #|:derive-type #'result-type-last-arg|#)
 
   #|:derive-type #'result-type-last-arg|#)
 

-(defknown array-has-fill-pointer-p (array) boolean
+(defknown bit-vector-= (bit-vector bit-vector) boolean

   (movable foldable flushable))
   (movable foldable flushable))

-(defknown fill-pointer (vector) index (foldable unsafely-flushable))
-(defknown vector-push (t vector) (or index null) ())
-(defknown vector-push-extend (t vector &optional index) index ())
-(defknown vector-pop (vector) t ())

 
 

+(defknown array-has-fill-pointer-p (array) boolean
+  (movable foldable flushable))
+(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 complex-vector &optional (and index (integer 1))) index
+    (explicit-check)
+  :destroyed-constant-args (nth-constant-args 2))
+(defknown vector-pop (complex-vector) t
+    (explicit-check)
+  :destroyed-constant-args (nth-constant-args 1))
+
+;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
+;;; Also, an important-result warning could be provided if the array
+;;; is known to be not expressly adjustable.

 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)

-        (:initial-element t) (:initial-contents list)
-        (:fill-pointer t) (:displaced-to (or array null))
-        (:displaced-index-offset index))
-  array (unsafe))
+         (:initial-element t) (:initial-contents t)
+         (:fill-pointer t) (:displaced-to (or array null))
+         (:displaced-index-offset index))
+  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:

@@ -829,56 +934,55 @@
 (defknown char (string index) character (foldable flushable))
 (defknown schar (simple-string index) character (foldable flushable))
 
 (defknown char (string index) character (foldable flushable))
 (defknown schar (simple-string index) character (foldable flushable))
 

-(sb!xc:deftype stringable () '(or character string symbol))
-

 (defknown (string= string-equal)
 (defknown (string= string-equal)

-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
-             (:start2 index) (:end2 sequence-end))
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
+              (:start2 index) (:end2 sequence-end))

   boolean
   (foldable flushable))
 
 (defknown (string< string> string<= string>= string/= string-lessp
   boolean
   (foldable flushable))
 
 (defknown (string< string> string<= string>= string/= string-lessp

-                  string-greaterp string-not-lessp string-not-greaterp
-                  string-not-equal)
-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
-             (:start2 index) (:end2 sequence-end))
+                   string-greaterp string-not-lessp string-not-greaterp
+                   string-not-equal)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)
+              (:start2 index) (:end2 sequence-end))

   (or index null)
   (foldable flushable))
 
 (defknown make-string (index &key (:element-type type-specifier)
   (or index null)
   (foldable flushable))
 
 (defknown make-string (index &key (:element-type type-specifier)

-                      (:initial-element character))
+                       (:initial-element character))

   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)
   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)

-  (sequence stringable) simple-string (flushable))
+  (sequence string-designator) string (flushable))

 
 (defknown (string-upcase string-downcase string-capitalize)
 
 (defknown (string-upcase string-downcase string-capitalize)

-  (stringable &key (:start index) (:end sequence-end))
+  (string-designator &key (:start index) (:end sequence-end))

   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))
   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))

-  string ())
+  string ()
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))

 
 

-(defknown string (stringable) string
+(defknown string (string-designator) string

   (flushable explicit-check))
 \f
 ;;;; internal non-keyword versions of string predicates:
 
 (defknown (string<* string>* string<=* string>=* string/=*)
   (flushable explicit-check))
 \f
 ;;;; internal non-keyword versions of string predicates:
 
 (defknown (string<* string>* string<=* string>=* string/=*)

-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)

   (or index null)
   (foldable flushable))
 
 (defknown string=*
   (or index null)
   (foldable flushable))
 
 (defknown string=*

-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)

   boolean
   (foldable flushable))
 \f
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))
   boolean
   (foldable flushable))
 \f
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))

-(defknown constantp (t &optional lexenv) boolean
+(defknown constantp (t &optional lexenv-designator) boolean

   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:
   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:

@@ -888,9 +992,13 @@
 (defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
 (defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))
 (defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
 (defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))

-(defknown make-string-input-stream (string &optional index index) stream
-  (flushable unsafe))
-(defknown make-string-output-stream () stream (flushable))
+(defknown make-string-input-stream (string &optional index sequence-end)
+  stream
+  (flushable))
+(defknown make-string-output-stream
+    (&key (:element-type type-specifier))
+    string-output-stream
+  (flushable))

 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
 (defknown stream-element-type (stream) type-specifier
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
 (defknown stream-element-type (stream) type-specifier

@@ -911,61 +1019,97 @@
 (defknown readtablep (t) boolean (movable foldable flushable))
 
 (defknown set-syntax-from-char
 (defknown readtablep (t) boolean (movable foldable flushable))
 
 (defknown set-syntax-from-char

-  (character character &optional (or readtable null) readtable) (eql t)
+  (character character &optional readtable (or readtable null)) (eql t)

   ())
 
   ())
 

-(defknown set-macro-character (character callable &optional t readtable)
+(defknown set-macro-character (character callable &optional t (or readtable null))

   (eql t)
   (eql t)

-  (unsafe))
+  ())

 (defknown get-macro-character (character &optional (or readtable null))
   (values callable boolean) (flushable))
 
 (defknown make-dispatch-macro-character (character &optional t readtable)
   (eql t) ())
 (defknown set-dispatch-macro-character
 (defknown get-macro-character (character &optional (or readtable null))
   (values callable boolean) (flushable))
 
 (defknown make-dispatch-macro-character (character &optional t readtable)
   (eql t) ())
 (defknown set-dispatch-macro-character

-  (character character callable &optional readtable) function
-  (unsafe))
+  (character character callable &optional (or readtable null)) (eql t)
+  ())

 (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)
   ())
 

+(defknown copy-pprint-dispatch
+  (&optional (or sb!pretty:pprint-dispatch-table null))
+  sb!pretty:pprint-dispatch-table
+  ())
+(defknown pprint-dispatch
+  (t &optional (or sb!pretty:pprint-dispatch-table null))
+  (values callable boolean)
+  ())
+(defknown (pprint-fill pprint-linear)
+  (stream-designator t &optional t t)
+  null
+  ())
+(defknown pprint-tabular
+  (stream-designator t &optional t t unsigned-byte)
+  null
+  ())
+(defknown pprint-indent
+  ((member :block :current) real &optional stream-designator)
+  null
+  ())
+(defknown pprint-newline
+  ((member :linear :fill :miser :mandatory) &optional stream-designator)
+  null
+  ())
+(defknown pprint-tab
+  ((member :line :section :line-relative :section-relative)
+   unsigned-byte unsigned-byte &optional stream-designator)
+  null
+  ())
+(defknown set-pprint-dispatch
+  (type-specifier (or null callable)
+   &optional real sb!pretty:pprint-dispatch-table)
+  null
+  ())
+

 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)

-  (&optional streamlike t t t) t (explicit-check))
+  (&optional stream-designator t t t) t (explicit-check))

 
 

-(defknown read-delimited-list (character &optional streamlike t) t
+(defknown read-delimited-list (character &optional stream-designator t) list

   (explicit-check))
   (explicit-check))

-(defknown read-line (&optional streamlike t t t) (values t boolean)
+(defknown read-line (&optional stream-designator t t t) (values t boolean)

   (explicit-check))
   (explicit-check))

-(defknown unread-char (character &optional streamlike) t
+(defknown unread-char (character &optional stream-designator) t

   (explicit-check))
   (explicit-check))

-(defknown peek-char (&optional (or character (member nil t)) streamlike t t t)
+(defknown peek-char (&optional (or character (member nil t))
+                               stream-designator t t t)

   t
   (explicit-check))
   t
   (explicit-check))

-(defknown listen (&optional streamlike) boolean (flushable explicit-check))
+(defknown listen (&optional stream-designator) boolean (flushable explicit-check))

 
 

-(defknown clear-input (&optional stream) null (explicit-check))
+(defknown clear-input (&optional stream-designator) null (explicit-check))

 
 (defknown read-from-string
   (string &optional t t
 
 (defknown read-from-string
   (string &optional t t

-         &key
-         (:start index)
-         (:end sequence-end)
-         (:preserve-whitespace t))
+          &key
+          (:start index)
+          (:end sequence-end)
+          (:preserve-whitespace t))

   (values t index))
 (defknown parse-integer
   (string &key
   (values t index))
 (defknown parse-integer
   (string &key

-         (:start index)
-         (:end sequence-end)
-         (:radix (integer 2 36))
-         (:junk-allowed t))
+          (:start index)
+          (:end sequence-end)
+          (:radix (integer 2 36))
+          (:junk-allowed t))

   (values (or integer null ()) index))
 
 (defknown read-byte (stream &optional t t) t (explicit-check))
 
 (defknown write
   (t &key
   (values (or integer null ()) index))
 
 (defknown read-byte (stream &optional t t) t (explicit-check))
 
 (defknown write
   (t &key

-     (:stream streamlike)
+     (:stream stream-designator)

      (:escape t)
      (:radix t)
      (:base (integer 2 36))
      (:escape t)
      (:radix t)
      (:base (integer 2 36))

@@ -980,16 +1124,20 @@
      (: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)
 

-(defknown (prin1 print princ) (t &optional streamlike) t (any explicit-check)
+(defknown (prin1 print princ) (t &optional stream-designator)
+  t
+  (any explicit-check)

   :derive-type #'result-type-first-arg)
 
 ;;; xxx-TO-STRING functions are not foldable because they depend on
   :derive-type #'result-type-first-arg)
 
 ;;; xxx-TO-STRING functions are not foldable because they depend on

-;;; the dynamic environment.
+;;; the dynamic environment, the state of the pretty printer dispatch
+;;; table, and probably other run-time factors.

 (defknown write-to-string
   (t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
      (:circle t) (:pretty t) (:level (or unsigned-byte null))
 (defknown write-to-string
   (t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
      (:circle t) (:pretty t) (:level (or unsigned-byte null))

@@ -997,28 +1145,30 @@
      (:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
   simple-string
      (:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
   simple-string

-  (foldable flushable explicit-check))
+  (flushable explicit-check))

 
 (defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
 
 
 (defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
 

-(defknown write-char (character &optional streamlike) character
+(defknown write-char (character &optional stream-designator) character

   (explicit-check))
 (defknown (write-string write-line)
   (explicit-check))
 (defknown (write-string write-line)

-  (string &optional streamlike &key (:start index) (:end sequence-end))
+  (string &optional stream-designator &key (:start index) (:end sequence-end))

   string
   (explicit-check))
 
 (defknown (terpri finish-output force-output clear-output)
   string
   (explicit-check))
 
 (defknown (terpri finish-output force-output clear-output)

-  (&optional streamlike) null
+  (&optional stream-designator) null

   (explicit-check))
 
   (explicit-check))
 

-(defknown fresh-line (&optional streamlike) boolean
+(defknown fresh-line (&optional stream-designator) boolean

   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 
   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 

-(defknown format ((or streamlike string) (or string function) &rest t)
+;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
+(defknown format ((or (member nil t) stream string)
+                  (or string function) &rest t)

   (or string null)
   (explicit-check))
 
   (or string null)
   (explicit-check))
 

@@ -1033,43 +1183,47 @@
 ;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
 
 (defknown wild-pathname-p (pathname-designator
 ;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)
 
 (defknown wild-pathname-p (pathname-designator

-                          &optional
-                          (member nil :host :device
-                                  :directory :name
-                                  :type :version))
-  boolean
-  ())
-(defknown pathname-match-p (pathname-designator pathname-designator) boolean
+                           &optional
+                           (member nil :host :device
+                                   :directory :name
+                                   :type :version))
+  generalized-boolean
+  (recursive))
+
+(defknown pathname-match-p (pathname-designator pathname-designator)
+  generalized-boolean

   ())
   ())

+

 (defknown translate-pathname (pathname-designator
 (defknown translate-pathname (pathname-designator

-                             pathname-designator
-                             pathname-designator &key)
+                              pathname-designator
+                              pathname-designator &key)

   pathname
   ())
 
 (defknown logical-pathname (pathname-designator) logical-pathname ())
   pathname
   ())
 
 (defknown logical-pathname (pathname-designator) logical-pathname ())

-(defknown translate-logical-pathname (pathname-designator &key) pathname ())
+(defknown translate-logical-pathname (pathname-designator &key) pathname
+  (recursive))

 (defknown load-logical-pathname-translations (string) t ())
 (defknown logical-pathname-translations (logical-host-designator) list ())
 
 (defknown load-logical-pathname-translations (string) t ())
 (defknown logical-pathname-translations (logical-host-designator) list ())
 

-(defknown pathname (pathname-designator) pathname (unsafely-flushable))
+(defknown pathname (pathname-designator) pathname ())

 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
   (pathname-designator &optional
                        (or list host string (member :unspecific))
                        pathname-designator
 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
   (pathname-designator &optional
                        (or list host string (member :unspecific))
                        pathname-designator

-                      &key
-                      (:start index)
-                      (:end sequence-end)
-                      (:junk-allowed t))
+                       &key
+                       (:start index)
+                       (:end sequence-end)
+                       (:junk-allowed t))

   (values (or pathname null) sequence-end)
   (values (or pathname null) sequence-end)

-  ())
+  (recursive))

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

-  (unsafely-flushable))
+  ())

 
 (defknown make-pathname
  (&key (:defaults pathname-designator)
 
 (defknown make-pathname
  (&key (:defaults pathname-designator)

@@ -1084,25 +1238,27 @@
 (defknown pathnamep (t) boolean (movable flushable))
 
 (defknown pathname-host (pathname-designator
 (defknown pathnamep (t) boolean (movable flushable))
 
 (defknown pathname-host (pathname-designator

-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))

   pathname-host (flushable))
 (defknown pathname-device (pathname-designator
   pathname-host (flushable))
 (defknown pathname-device (pathname-designator

-                          &key (:case (member :local :common)))
+                           &key (:case (member :local :common)))

   pathname-device (flushable))
 (defknown pathname-directory (pathname-designator
   pathname-device (flushable))
 (defknown pathname-directory (pathname-designator

-                             &key (:case (member :local :common)))
+                              &key (:case (member :local :common)))

   pathname-directory (flushable))
 (defknown pathname-name (pathname-designator
   pathname-directory (flushable))
 (defknown pathname-name (pathname-designator

-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))

   pathname-name (flushable))
 (defknown pathname-type (pathname-designator
   pathname-name (flushable))
 (defknown pathname-type (pathname-designator

-                        &key (:case (member :local :common)))
+                         &key (:case (member :local :common)))

   pathname-type (flushable))
 (defknown pathname-version (pathname-designator)
   pathname-version (flushable))
 
   pathname-type (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)
 (defknown (namestring file-namestring directory-namestring host-namestring)

-  (pathname-designator) simple-string
+  (pathname-designator) (or simple-string null)

   (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
   (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)

@@ -1113,13 +1269,13 @@
 
 (defknown open
   (pathname-designator &key
 
 (defknown open
   (pathname-designator &key

-                      (:direction (member :input :output :io :probe))
-                      (:element-type type-specifier)
-                      (:if-exists (member :error :new-version :rename
-                                          :rename-and-delete :overwrite
-                                          :append :supersede nil))
-                      (:if-does-not-exist (member :error :create nil))
-                      (:external-format (member :default)))
+                       (:direction (member :input :output :io :probe))
+                       (:element-type type-specifier)
+                       (:if-exists (member :error :new-version :rename
+                                           :rename-and-delete :overwrite
+                                           :append :supersede nil))
+                       (:if-does-not-exist (member :error :create nil))
+                       (:external-format external-format-designator))

   (or stream null))
 
 (defknown rename-file (pathname-designator filename)
   (or stream null))
 
 (defknown rename-file (pathname-designator filename)

@@ -1132,7 +1288,7 @@
   ())
 
 (defknown file-position (stream &optional
   ())
 
 (defknown file-position (stream &optional

-                               (or unsigned-byte (member :start :end)))
+                                (or unsigned-byte (member :start :end)))

   (or unsigned-byte (member t nil)))
 (defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
 
   (or unsigned-byte (member t nil)))
 (defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))
 

@@ -1141,22 +1297,39 @@
    &key
    (:verbose t)
    (:print t)
    &key
    (:verbose t)
    (:print t)

-   (:if-does-not-exist (member :error :create nil))
-   (:external-format (member :default)))
+   (:if-does-not-exist t)
+   (:external-format external-format-designator))

   t)
 
   t)
 

-(defknown directory (pathname-designator &key)
+(defknown directory (pathname-designator &key (:resolve-symlinks t))

   list ())
 \f
   list ())
 \f

-;;;; from the "Errors" chapter:
+;;;; from the "Conditions" chapter:

 
 

-(defknown error (t &rest t) nil) ; never returns
-(defknown cerror (string 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 warn (t &rest t) null)
 (defknown warn (t &rest t) null)

-(defknown break (&optional t &rest t) null)
+(defknown invoke-debugger (condition) nil)
+(defknown break (&optional format-control &rest t) null)
+(defknown make-condition (type-specifier &rest t) condition)
+(defknown compute-restarts (&optional (or condition null)) list)
+(defknown find-restart (restart-designator &optional (or condition null))
+  (or restart null))
+(defknown invoke-restart (restart-designator &rest t) *)
+(defknown invoke-restart-interactively (restart-designator) *)
+(defknown restart-name (restart) symbol)
+(defknown (abort muffle-warning) (&optional (or condition null)) nil)
+(defknown continue (&optional (or condition null)) null)
+(defknown (store-value use-value) (t &optional (or condition null))
+  null)

 
 ;;; and analogous SBCL extension:
 
 ;;; and analogous SBCL extension:

+(defknown sb!impl::%failed-aver (t) nil)

 (defknown bug (t &rest t) nil) ; never returns
 (defknown bug (t &rest t) nil) ; never returns

+

 \f
 ;;;; from the "Miscellaneous" Chapter:
 
 \f
 ;;;; from the "Miscellaneous" Chapter:
 

@@ -1164,54 +1337,52 @@
   (values (or function symbol cons) boolean boolean))
 
 (defknown compile-file
   (values (or function symbol cons) boolean boolean))
 
 (defknown compile-file

-  (filename
+  (pathname-designator

    &key
 
    ;; ANSI options
    &key
 
    ;; ANSI options

-   (:output-file (or filename
-                    null
-                    ;; FIXME: This last case is a non-ANSI hack.
-                    (member t)))
+   (:output-file (or pathname-designator
+                     null
+                     ;; FIXME: This last case is a non-ANSI hack.
+                     (member t)))

    (:verbose t)
    (:print t)
    (:verbose t)
    (:print t)

-   (:external-format t)
+   (:external-format external-format-designator)

 
    ;; extensions
    (:trace-file t)
 
    ;; extensions
    (:trace-file t)

-   (:block-compile t))
+   (:block-compile t)
+   (:emit-cfasl t))

   (values (or pathname null) boolean boolean))
 
   (values (or pathname null) boolean boolean))
 

-(defknown disassemble (callable &key
-                               (:stream stream)
-                               (:use-labels t))
+;; FIXME: consider making (OR CALLABLE CONS) something like
+;; EXTENDED-FUNCTION-DESIGNATOR
+(defknown disassemble ((or callable cons) &key
+                       (:stream stream) (:use-labels t))

   null)
 
   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))
 (defknown describe (t &optional (or stream (member t nil))) (values))
 (defknown inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))

-(defknown ed (&optional (or symbol cons filename) &key (:init t) (:display t))
+(defknown ed (&optional (or symbol cons filename))

   t)
 (defknown dribble (&optional filename &key (:if-exists t)) (values))
 
   t)
 (defknown dribble (&optional filename &key (:if-exists t)) (values))
 

-(defknown apropos      (stringable &optional package-designator t) (values))
-(defknown apropos-list (stringable &optional package-designator t) list
-  (flushable))
+(defknown apropos      (string-designator &optional package-designator t) (values))
+(defknown apropos-list (string-designator &optional package-designator t) list
+  (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)

-         (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
+          (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))

   (flushable))
 
 (defknown get-universal-time () unsigned-byte (flushable))
 
 (defknown decode-universal-time
   (flushable))
 
 (defknown get-universal-time () unsigned-byte (flushable))
 
 (defknown decode-universal-time

-         (unsigned-byte &optional (or null (rational -24 24)))
+          (unsigned-byte &optional (or null (rational -24 24)))

   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)

-         (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))
+          (integer 1 12) unsigned-byte (integer 0 6) boolean (rational -24 24))

   (flushable))
 
 (defknown encode-universal-time
   (flushable))
 
 (defknown encode-universal-time

@@ -1223,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

@@ -1236,11 +1407,11 @@
 ;;; available, so -- unlike the related LISP-IMPLEMENTATION-FOO
 ;;; functions -- these really can return NIL.
 (defknown (machine-type machine-version machine-instance
 ;;; available, so -- unlike the related LISP-IMPLEMENTATION-FOO
 ;;; functions -- these really can return NIL.
 (defknown (machine-type machine-version machine-instance

-          software-type software-version
-          short-site-name long-site-name)
+           software-type software-version
+           short-site-name long-site-name)

   () (or simple-string null) (flushable))
 
   () (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))

@@ -1248,23 +1419,33 @@
 \f
 ;;;; miscellaneous extensions
 
 \f
 ;;;; miscellaneous extensions
 

+(defknown symbol-global-value (symbol) t ())
+(defknown set-symbol-global-value (symbol t) t ())
+

 (defknown get-bytes-consed () unsigned-byte (flushable))
 (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))

 \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))
+

 ;;; 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
 ;;; 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)
 
 (defknown %cleanup-point () t)
 (defknown %special-bind (t t) t)

@@ -1272,6 +1453,10 @@
 (defknown %listify-rest-args (t index) list (flushable))
 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)
 (defknown %listify-rest-args (t index) list (flushable))
 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)

+#!+stack-grows-downward-not-upward
+;;; FIXME: The second argument here should really be NEGATIVE-INDEX, but doing that
+;;; breaks the build, and I cannot seem to figure out why. --NS 2006-06-29
+(defknown %more-kw-arg (t fixnum) (values t t))

 (defknown %more-arg-values (t index index) * (flushable))
 (defknown %verify-arg-count (index index) (values))
 (defknown %arg-count-error (t) nil)
 (defknown %more-arg-values (t index index) * (flushable))
 (defknown %verify-arg-count (index index) (values))
 (defknown %arg-count-error (t) nil)

@@ -1285,7 +1470,15 @@
 (defknown %nlx-entry (t) *)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
 (defknown %nlx-entry (t) *)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)

+(defknown %nip-values (t t &rest t) (values))
+(defknown %allocate-closures (t) *)

 (defknown %type-check-error (t t) nil)
 (defknown %type-check-error (t t) nil)

+
+;; 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 t) *)
+(defknown sb!kernel::case-failure (t t t) nil)
+

 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte

@@ -1293,21 +1486,37 @@
 (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 flushable explicit-check))
-(defknown data-vector-set (array index t) t (unsafe explicit-check))
+  (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
+  (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
 (defknown hairy-data-vector-ref (array index) t

-  (foldable flushable explicit-check))
-(defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
-(defknown sb!kernel:%caller-frame-and-pc () (values t t) (flushable))
-(defknown sb!kernel:%with-array-data (array index (or index null))
+  (foldable 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
+  (explicit-check))
+(defknown %caller-frame () t (flushable))
+(defknown %caller-pc () system-area-pointer (flushable))
+(defknown %with-array-data (array index (or index null))

   (values (simple-array * (*)) index index index)
   (foldable flushable))
   (values (simple-array * (*)) index index index)
   (foldable flushable))

-(defknown %set-symbol-package (symbol t) t (unsafe))
+(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 ())

 (defknown %coerce-name-to-fun ((or symbol cons)) function (flushable))
 (defknown %coerce-callable-to-fun (callable) function (flushable))
 (defknown %coerce-name-to-fun ((or symbol cons)) function (flushable))
 (defknown %coerce-callable-to-fun (callable) function (flushable))

-(defknown failed-%with-array-data (t t t) nil)
+(defknown array-bounding-indices-bad-error (t t t) nil)
+(defknown sequence-bounding-indices-bad-error (t t t) nil)

 (defknown %find-position
   (t sequence t index sequence-end function function)
   (values t (or index null))
 (defknown %find-position
   (t sequence t index sequence-end function function)
   (values t (or index null))

@@ -1316,32 +1525,130 @@
   (function sequence t index sequence-end function)
   (values t (or index null))
   (call))
   (function sequence t index sequence-end function)
   (values t (or index null))
   (call))

+(defknown effective-find-position-test (callable callable)
+  function
+  (flushable foldable))
+(defknown effective-find-position-key (callable)
+  function
+  (flushable foldable))
+
+(defknown %adjoin     (t list)          list (explicit-check foldable flushable))
+(defknown %adjoin-key (t list function) list (explicit-check foldable flushable call))
+(defknown %assoc      (t list)          list (explicit-check foldable flushable))
+(defknown %assoc-key  (t list function) list (explicit-check foldable flushable call))
+(defknown %member     (t list)          list (explicit-check foldable flushable))
+(defknown %member-key (t list function) list (explicit-check foldable flushable call))
+(defknown %rassoc     (t list)          list (explicit-check foldable flushable))
+(defknown %rassoc-key (t list function) list (explicit-check foldable flushable call))
+
+(defknown %check-vector-sequence-bounds (vector index sequence-end)
+  index
+  (unwind))
+;;; FIXME: including this information here is probably necessary to
+;;; get efficient compilation of the inline expansion of
+;;; %FIND-POSITION-IF, so it should maybe be in a more
+;;; compiler-friendly package (SB-INT?)
+(defknown sb!impl::signal-bounding-indices-bad-error
+    (sequence index sequence-end)
+  nil) ; never returns
+

 
 

-(defknown sb!kernel::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 %set-row-major-aref (array index t) t (unsafe))
-(defknown %rplaca (cons t) t (unsafe))
-(defknown %rplacd (cons t) t (unsafe))
-(defknown %put (symbol t t) t (unsafe))
-(defknown %setelt (sequence index t) t (unsafe))
-(defknown %svset (simple-vector index t) t (unsafe))
-(defknown %bitset (bit-vector &rest index) bit (unsafe))
-(defknown %sbitset (simple-bit-vector &rest index) bit (unsafe))
-(defknown %charset (string index character) character (unsafe))
-(defknown %scharset (simple-string index character) character (unsafe))
-(defknown %set-symbol-value (symbol t) t (unsafe))
-(defknown (setf symbol-function) (function symbol) function (unsafe))
-(defknown %set-symbol-plist (symbol t) t (unsafe))
-(defknown (setf fdocumentation) ((or string null) t symbol)
-  (or string null)
-  ())
-(defknown %setnth (index list t) t (unsafe))
-(defknown %set-fill-pointer (vector index) index (unsafe))
+(defknown %aset (array &rest t) t ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown %set-row-major-aref (array index t) t ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown (%rplaca %rplacd) (cons t) t ()
+  :destroyed-constant-args (nth-constant-args 1))
+(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 ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown %bitset ((array bit) &rest index) bit ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown %sbitset ((simple-array bit) &rest index) bit ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown %charset (string index character) character ()
+  :destroyed-constant-args (nth-constant-args 1))
+(defknown %scharset (simple-string index character) character ()
+  :destroyed-constant-args (nth-constant-args 1))
+(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 (complex-vector index) index
+    (explicit-check)
+  :destroyed-constant-args (nth-constant-args 1))

 \f
 \f

+;;;; ALIEN and call-out-to-C stuff
+
+;; Used by WITH-PINNED-OBJECTS
+#!+(or x86 x86-64)
+(defknown sb!vm::touch-object (t) (values)
+    (always-translatable))
+
+#!+linkage-table
+(defknown foreign-symbol-dataref-sap (simple-string)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-sap (simple-string &optional boolean)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-address (simple-string &optional boolean)
+  (values integer boolean)
+  (movable flushable))
+

 ;;;; 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 compiler-error (t &rest t) nil ())
+(defknown (compiler-warn compiler-style-warn) (t &rest t) (values) ())
+(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
+  (values)
+  ())
+(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
+    ())
+(defknown %compare-and-swap-instance-ref (instance index t t) t
+    ())
+(defknown %compare-and-swap-symbol-value (symbol t t) t
+    (unwind))
+(defknown spin-loop-hint () (values)
+    (always-translatable))