0.9.2.47:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index ca85fa7..704e7f0 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -17,24 +17,8 @@
 
 (defknown coerce (t type-specifier) t
   ;; Note:
 
 (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)
+  ;; 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.
   )
   ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
   ;; returns REAL/INTEGER, not COMPLEX.
   )

@@ -44,8 +28,8 @@
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.

-(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)
-         (type-specifier &optional lexenv-designator) type-specifier
+(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:
   (unsafely-flushable))
 \f
 ;;;; from the "Predicates" chapter:

@@ -85,9 +69,9 @@
   (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))
   (t) boolean (movable foldable flushable))
 
 (defknown (eq eql) (t t) boolean (movable foldable flushable))

@@ -181,21 +165,18 @@
 (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))

@@ -214,15 +195,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 unexport (symbols-designator &optional package-designator) (eql t))
+(defknown shadowing-import (symbols-designator &optional package-designator)
+  (eql t))

 (defknown shadow ((or symbol string list) &optional package-designator)
   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))
 (defknown shadow ((or symbol string list) &optional package-designator)
   (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:
 

@@ -336,22 +319,22 @@
   (movable foldable flushable explicit-check))
 
 (defknown (ffloor fceiling fround ftruncate)
   (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))
   (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
+(defknown scale-float (float integer) float

   (movable foldable unsafely-flushable explicit-check))
 (defknown float-radix (float) float-radix
   (movable foldable unsafely-flushable explicit-check))
 (defknown float-radix (float) float-radix

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

 (defknown float-sign (float &optional float) float
   (movable foldable flushable explicit-check))
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)
 (defknown float-sign (float &optional float) float
   (movable foldable flushable explicit-check))
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)

-         (values integer float-int-exponent (member -1 1))
-         (movable foldable flushable explicit-check))
+          (values integer float-int-exponent (member -1 1))
+          (movable foldable 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))

@@ -362,7 +345,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

@@ -370,7 +353,7 @@
 
 (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 (logcount integer-length) (integer) bit-index
 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (defknown (logcount integer-length) (integer) bit-index

@@ -393,21 +376,22 @@
   (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 random ((or (float (0.0)) (integer 1)) &optional random-state)
+  (or (float 0.0) (integer 0)) ())

 (defknown make-random-state (&optional (or (member nil t) random-state))
   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
 (defknown make-random-state (&optional (or (member nil t) random-state))
   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))
 
 (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
   (character) boolean (movable foldable flushable))
 
 (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

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

@@ -419,9 +403,9 @@
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string 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

@@ -451,8 +435,8 @@
   :derive-type #'result-type-first-arg)
 
 (defknown make-sequence (type-specifier index
   :derive-type #'result-type-first-arg)
 
 (defknown make-sequence (type-specifier index

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

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

@@ -488,13 +472,13 @@
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable

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

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

@@ -503,12 +487,12 @@
   :derive-type #'result-type-first-arg)
 
 (defknown replace (sequence
   :derive-type #'result-type-first-arg)
 
 (defknown replace (sequence

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

   sequence ()
   :derive-type #'result-type-first-arg)
 
   sequence ()
   :derive-type #'result-type-first-arg)
 

@@ -530,7 +514,7 @@
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-           (:count sequence-count) (:key callable))
+            (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))

@@ -560,7 +544,7 @@
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-           (:count sequence-count) (:key callable))
+            (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))

@@ -574,59 +558,59 @@
 
 (defknown remove-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
 
 (defknown remove-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)

-           (:from-end t) (:end sequence-end) (:key callable))
+            (:from-end t) (:end sequence-end) (:key callable))

   consed-sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
   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))
+            (:from-end t) (:end sequence-end) (:key callable))

   sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)
   sequence
   (unsafely-flushable call)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)

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

   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   t
   (foldable flushable call))
 
 (defknown (find-if find-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

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

   t
   (foldable flushable call))
 
 (defknown position (t sequence &key (:test callable) (:test-not callable)
   t
   (foldable flushable call))
 
 (defknown position (t sequence &key (:test callable) (:test-not callable)

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

   (or index null)
   (foldable flushable call))
 
 (defknown (position-if position-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   (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))
+            (:key callable))

   (or index null)
   (foldable flushable call))
 
 (defknown count (t sequence &key (:test callable) (:test-not callable)
   (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))
+                      (:start index) (:from-end t) (:end sequence-end)
+                      (:key callable))

   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   index
   (foldable flushable call))
 
 (defknown (count-if count-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

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

   index
   (foldable flushable call))
 
 (defknown (mismatch search)
   (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
   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))
+            (:start1 index) (:end1 sequence-end)
+            (:start2 index) (:end2 sequence-end)
+            (:key callable))

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

@@ -639,23 +623,23 @@
   (call))
 
 (defknown merge (type-specifier sequence sequence callable
   (call))
 
 (defknown merge (type-specifier sequence sequence callable

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

   sequence
   (call)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
   sequence
   (call)
   :derive-type (creation-result-type-specifier-nth-arg 1))
 
 ;;; 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))

@@ -713,19 +697,19 @@
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)

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

   t (flushable unsafe call))
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
   t (flushable unsafe call))
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)

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

   t (flushable unsafe call))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
   t (flushable unsafe call))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)

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

   t (flushable unsafe call))
 
 (defknown member (t list &key (:key callable) (:test callable)
   t (flushable unsafe call))
 
 (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))

@@ -733,7 +717,7 @@
 (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))
+                    (:test-not callable))

   list (foldable flushable unsafe call))
 
 (defknown (union intersection set-difference set-exclusive-or)
   list (foldable flushable unsafe call))
 
 (defknown (union intersection set-difference set-exclusive-or)

@@ -755,10 +739,10 @@
 (defknown pairlis (t t &optional t) list (flushable unsafe))
 
 (defknown (rassoc assoc)
 (defknown pairlis (t t &optional t) list (flushable unsafe))
 
 (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 unsafe))
 (defknown delq (t list) list (flushable unsafe))

@@ -787,19 +771,19 @@
 (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)
 (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))
+  (#-sb-xc-host 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))
+                      &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))
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
   array (flushable unsafe))
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))

@@ -824,15 +808,15 @@
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
 (defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2

-                  bit-orc1 bit-orc2)
+                   bit-orc1 bit-orc2)

   ((array bit) (array bit) &optional (or (array bit) (member t nil)))
   (array bit)
   ((array bit) (array bit) &optional (or (array bit) (member t nil)))
   (array bit)

-  (foldable)
+  ()

   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))
   (array bit)
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))
   (array bit)

-  (foldable)
+  ()

   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-vector-= (bit-vector bit-vector) boolean
   #|:derive-type #'result-type-last-arg|#)
 
 (defknown bit-vector-= (bit-vector bit-vector) boolean

@@ -847,9 +831,9 @@
 
 (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 t)
-        (:fill-pointer t) (:displaced-to (or array null))
-        (:displaced-index-offset index))
+         (:initial-element t) (:initial-contents t)
+         (:fill-pointer t) (:displaced-to (or array null))
+         (:displaced-index-offset index))

   array (unsafe))
 ;  :derive-type 'result-type-arg1) Not even close...
 \f
   array (unsafe))
 ;  :derive-type 'result-type-arg1) Not even close...
 \f

@@ -858,49 +842,47 @@
 (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) simple-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))
   string ())
 
   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))
   string ())
 

-(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
   boolean
   (foldable flushable))
 \f

@@ -917,11 +899,12 @@
 (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
+(defknown make-string-input-stream (string &optional index sequence-end)
+  stream

   (flushable unsafe))
   (flushable unsafe))

-(defknown make-string-output-stream 
-    (&key (:element-type type-specifier)) 
-    stream 
+(defknown make-string-output-stream
+    (&key (:element-type type-specifier))
+    stream

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

@@ -961,43 +944,79 @@
   (character character &optional (or readtable null)) (or callable null)
   ())
 
   (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) list
+(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))

@@ -1017,11 +1036,14 @@
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
   (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))

@@ -1029,28 +1051,29 @@
      (: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)
+(defknown format ((or (member nil t) stream string)
+                  (or string function) &rest t)

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

@@ -1065,18 +1088,18 @@
 ;;; 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))
+                           &optional
+                           (member nil :host :device
+                                   :directory :name
+                                   :type :version))

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

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

   pathname
   ())
 
   pathname
   ())
 

@@ -1093,10 +1116,10 @@
   (pathname-designator &optional
                        (or list host string (member :unspecific))
                        pathname-designator
   (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)
   ())
 

@@ -1118,19 +1141,19 @@
 (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))

@@ -1147,13 +1170,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 keyword))

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

@@ -1166,7 +1189,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))
 

@@ -1176,7 +1199,7 @@
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))

-   (:external-format (member :default)))
+   (:external-format keyword))

   t)
 
 (defknown directory (pathname-designator &key)
   t)
 
 (defknown directory (pathname-designator &key)

@@ -1218,17 +1241,17 @@
   (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 keyword)

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

@@ -1238,7 +1261,7 @@
 ;; FIXME: consider making (OR CALLABLE CONS) something like
 ;; EXTENDED-FUNCTION-DESIGNATOR
 (defknown disassemble ((or callable cons) &key
 ;; FIXME: consider making (OR CALLABLE CONS) something like
 ;; EXTENDED-FUNCTION-DESIGNATOR
 (defknown disassemble ((or callable cons) &key

-                      (:stream stream) (:use-labels t))
+                       (:stream stream) (:use-labels t))

   null)
 
 (defknown fdocumentation (t symbol)
   null)
 
 (defknown fdocumentation (t symbol)

@@ -1248,25 +1271,25 @@
 (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
+(defknown apropos      (string-designator &optional package-designator t) (values))
+(defknown apropos-list (string-designator &optional package-designator t) list

   (flushable))
 
 (defknown get-decoded-time ()
   (values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
   (flushable))
 
 (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

@@ -1291,8 +1314,8 @@
 ;;; 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))
 
 (defknown identity (t) t (movable foldable flushable unsafe)
   () (or simple-string null) (flushable))
 
 (defknown identity (t) t (movable foldable flushable unsafe)

@@ -1304,6 +1327,8 @@
 ;;;; miscellaneous extensions
 
 (defknown get-bytes-consed () unsigned-byte (flushable))
 ;;;; miscellaneous extensions
 
 (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)
 
 ;;; PCOUNTERs
 (defknown incf-pcounter (pcounter unsigned-byte) pcounter)

@@ -1340,10 +1365,12 @@
 (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)
 
 ;; FIXME: This function does not return, but due to the implementation
 (defknown %type-check-error (t t) nil)
 
 ;; FIXME: This function does not return, but due to the implementation

-;; of FILTER-CONTINUATION we cannot write it here.
+;; of FILTER-LVAR we cannot write it here.

 (defknown %compile-time-type-error (t t t) *)
 
 (defknown %odd-key-args-error () nil)
 (defknown %compile-time-type-error (t t t) *)
 
 (defknown %odd-key-args-error () nil)

@@ -1393,7 +1420,7 @@
 (defknown sb!impl::signal-bounding-indices-bad-error
     (sequence index sequence-end)
   nil) ; never returns
 (defknown sb!impl::signal-bounding-indices-bad-error
     (sequence index sequence-end)
   nil) ; never returns

-  
+

 
 (defknown arg-count-error (t t t t t t) nil (unsafe))
 \f
 
 (defknown arg-count-error (t t t t t t) nil (unsafe))
 \f

@@ -1419,6 +1446,26 @@
 (defknown %setnth (unsigned-byte list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f
 (defknown %setnth (unsigned-byte list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f

+;;;; ALIEN and call-out-to-C stuff
+
+;;; 'unsafe' attribute because we store the arg on the stack, which is in
+;;; some sense 'passing it upwards'
+(defknown sb!vm::push-word-on-c-stack (system-area-pointer) (values) (unsafe))
+(defknown sb!vm::pop-words-from-c-stack (index) (values) ())
+
+#!+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))

@@ -1433,3 +1480,4 @@
   (values)
   ())
 (defknown style-warn (string &rest t) null ())
   (values)
   ())
 (defknown style-warn (string &rest t) null ())

+