0.8.9.10:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index e5d27c7..ec1de82 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -44,7 +44,7 @@
 (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 upgraded-array-element-type)
+(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)

          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 \f
          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 \f

@@ -185,17 +185,14 @@
 \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 +211,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,21 +335,21 @@
   (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))
 (defknown scale-float (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 float-radix (float) float-radix
 (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-exponent (member -1 1))
+         (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

@@ -370,7 +369,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,7 +392,8 @@
   (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))
 (defknown make-random-state (&optional (or (member nil t) random-state))
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))

@@ -419,7 +419,7 @@
 (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))
 (defknown code-char (char-code) base-char
   ;; By suppressing constant folding on CODE-CHAR when the
   (movable foldable flushable))
 (defknown code-char (char-code) base-char
   ;; By suppressing constant folding on CODE-CHAR when the

@@ -455,11 +455,11 @@
                                        (:initial-element t))
   consed-sequence
   (movable unsafe)
                                        (:initial-element t))
   consed-sequence
   (movable unsafe)

-  :derive-type (result-type-specifier-nth-arg 1))
+  :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

@@ -642,7 +642,7 @@
                                &key (:key callable))
   sequence
   (call)
                                &key (:key callable))
   sequence
   (call)

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

 
 ;;; 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

@@ -684,9 +684,9 @@
   (foldable flushable call))
 (defknown endp (list) boolean (foldable flushable movable))
 (defknown list-length (list) (or index null) (foldable unsafely-flushable))
   (foldable flushable call))
 (defknown endp (list) boolean (foldable flushable movable))
 (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) t (foldable flushable))
+(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 list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list
 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list

@@ -707,8 +707,8 @@
 (defknown nconc (&rest t) t ())
 
 (defknown nreconc (list t) t ())
 (defknown nconc (&rest t) t ())
 
 (defknown nreconc (list t) t ())

-(defknown butlast (list &optional index) list (flushable))
-(defknown nbutlast (list &optional index) list ())
+(defknown butlast (list &optional unsigned-byte) list (flushable))
+(defknown nbutlast (list &optional unsigned-byte) list ())

 (defknown ldiff (list t) list (flushable))
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown ldiff (list t) list (flushable))
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 

@@ -858,10 +858,8 @@
 (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)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)

              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))
              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))

@@ -869,7 +867,7 @@
 (defknown (string< string> string<= string>= string/= string-lessp
                   string-greaterp string-not-lessp string-not-greaterp
                   string-not-equal)
 (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)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)

              (:start2 index) (:end2 sequence-end))
   (or index null)
   (foldable flushable))
              (:start2 index) (:end2 sequence-end))
   (or index null)
   (foldable flushable))

@@ -879,28 +877,28 @@
   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,9 +915,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
+(defknown make-string-input-stream (string &optional index sequence-end)
+  stream

   (flushable unsafe))
   (flushable unsafe))

-(defknown make-string-output-stream () stream (flushable))
+(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))
 (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

@@ -958,22 +960,58 @@
   (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

@@ -994,7 +1032,7 @@
 
 (defknown write
   (t &key
 
 (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))

@@ -1014,7 +1052,9 @@
   (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

@@ -1030,24 +1070,25 @@
 
 (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))
 

@@ -1179,12 +1220,32 @@
 (defknown directory (pathname-designator &key)
   list ())
 \f
 (defknown directory (pathname-designator &key)
   list ())
 \f

-;;;; from the "Errors" chapter:
-
-(defknown error (t &rest t) nil) ; never returns
-(defknown cerror (string t &rest t) null)
+;;;; from the "Conditions" chapter:
+
+(defknown cell-error-name (cell-error) t)
+(defknown error (t &rest t) nil)
+(defknown cerror (format-control t &rest t) null)
+(defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
+(defknown method-combination-error (format-control &rest t) *)
+(defknown signal (t &rest t) null)
+(defknown simple-condition-format-control (condition)
+  format-control)
+(defknown simple-condition-format-arguments (condition)
+  list)

 (defknown warn (t &rest t) null)
 (defknown 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:
 (defknown bug (t &rest t) nil) ; never returns
 
 ;;; and analogous SBCL extension:
 (defknown bug (t &rest t) nil) ; never returns

@@ -1229,8 +1290,8 @@
   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 ()
   (flushable))
 
 (defknown get-decoded-time ()

@@ -1301,7 +1362,9 @@
 (defknown %cleanup-point () t)
 (defknown %special-bind (t t) t)
 (defknown %special-unbind (t) t)
 (defknown %cleanup-point () t)
 (defknown %special-bind (t t) t)
 (defknown %special-unbind (t) t)

-(defknown %listify-rest-args (t index) list (flushable))
+(defknown %dynamic-extent-start () t)
+(defknown %dynamic-extent-end () t)
+(defknown %listify-rest-args (t index t) list (flushable))

 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)
 (defknown %more-arg-values (t index index) * (flushable))
 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)
 (defknown %more-arg-values (t index index) * (flushable))

@@ -1320,7 +1383,7 @@
 (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,9 +1456,16 @@
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)
   ())
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)
   ())

-(defknown %setnth (index list t) t (unsafe))
+(defknown %setnth (unsigned-byte list t) t (unsafe))

 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f
 (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) ())
+

 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))

@@ -1403,3 +1473,10 @@
 
 (defknown policy-quality (policy symbol) policy-quality
           (flushable))
 
 (defknown policy-quality (policy symbol) policy-quality
           (flushable))

+
+(defknown (compiler-abort compiler-error) (string &rest t) nil ())
+(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
+  (values)
+  ())
+(defknown style-warn (string &rest t) null ())