;;;; information for known functions:
(defknown coerce (t type-specifier) t
- ;; Note:
- ;; This is not FLUSHABLE because it's defined to signal errors.
- (movable)
+ ;; 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.
)
;;; These can be affected by type definitions, so they're not FOLDABLE.
(defknown (sb!xc:upgraded-complex-part-type sb!xc:upgraded-array-element-type)
- (type-specifier &optional lexenv-designator) type-specifier
- (unsafely-flushable))
+ (type-specifier &optional lexenv-designator) type-specifier
+ (unsafely-flushable))
\f
;;;; from the "Predicates" chapter:
(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)
-(defknown classoid-name (classoid) name-for-class (flushable))
-(defknown find-classoid (name-for-class &optional t lexenv-designator)
+(defknown classoid-name (classoid) symbol (flushable))
+(defknown find-classoid (name-for-class &optional t)
(or classoid null) ())
(defknown classoid-of (t) classoid (flushable))
(defknown layout-of (t) layout (flushable))
(defknown copy-structure (structure-object) structure-object
- (flushable unsafe))
+ (flushable)) ;; FIXME: can derive the type based on the structure
\f
;;;; from the "Control Structure" chapter:
(defknown special-operator-p (symbol) t
;; The set of special operators never changes.
(movable foldable flushable))
-(defknown set (symbol t) t (unsafe)
+(defknown set (symbol t) t ()
:derive-type #'result-type-last-arg)
-(defknown fdefinition ((or symbol cons)) function (unsafe explicit-check))
+(defknown fdefinition ((or symbol cons)) function (explicit-check))
(defknown %set-fdefinition ((or symbol cons) function) function
- (unsafe explicit-check))
-(defknown makunbound (symbol) symbol)
+ (explicit-check)
+ :derive-type #'result-type-last-arg)
+(defknown makunbound (symbol) symbol
+ ()
+ :derive-type #'result-type-first-arg)
(defknown fmakunbound ((or symbol cons)) (or symbol cons)
- (unsafe explicit-check))
-(defknown (get-setf-method get-setf-method-multiple-value)
- ((or list symbol) &optional lexenv-designator)
- (values list list list form form)
- (flushable))
+ (explicit-check)
+ :derive-type #'result-type-first-arg)
(defknown apply (callable t &rest t) *) ; ### Last arg must be List...
(defknown funcall (callable &rest t) *)
;;; 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 macro-function (symbol &optional lexenv-designator)
(or function null)
(flushable))
-(defknown (macroexpand macroexpand-1) (t &optional lexenv-designator)
+(defknown (macroexpand macroexpand-1 %macroexpand %macroexpand-1)
+ (t &optional lexenv-designator)
(values form &optional boolean))
(defknown compiler-macro-function (t &optional lexenv-designator)
;;;; 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 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)
+(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))
(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 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 (numerator denominator) (rational) integer
(movable foldable flushable))
-(defknown (floor ceiling truncate round)
+(defknown (floor ceiling round)
(real &optional real) (values integer real)
(movable foldable flushable explicit-check))
+(defknown truncate
+ (real &optional real) (values integer real)
+ (movable foldable flushable explicit-check recursive))
+
+(defknown %multiply-high (word word) word
+ (movable foldable flushable))
+
+(defknown (%floor %ceiling)
+ (real real) (values integer real)
+ (movable foldable flushable explicit-check))
+
(defknown (mod rem) (real real) real
(movable foldable flushable explicit-check))
(movable foldable flushable explicit-check))
(defknown decode-float (float) (values float float-exponent float)
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown scale-float (float integer) float
(movable foldable unsafely-flushable explicit-check))
(defknown float-radix (float) float-radix
- (movable foldable flushable))
+ (movable foldable unsafely-flushable))
(defknown float-sign (float &optional float) float
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown (float-digits float-precision) (float) float-digits
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown integer-decode-float (float)
- (values integer float-int-exponent (member -1 1))
- (movable foldable flushable explicit-check))
+ (values integer float-int-exponent (member -1 1))
+ (movable foldable unsafely-flushable explicit-check))
(defknown complex (real &optional real) number
(movable foldable flushable explicit-check))
(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))
(defknown ash (integer integer) integer
(movable foldable flushable explicit-check))
+#!+ash-right-vops
+(defknown %ash/right ((or word sb!vm:signed-word) (mod #.sb!vm:n-word-bits))
+ (or word sb!vm:signed-word)
+ (movable foldable flushable always-translatable))
(defknown (logcount integer-length) (integer) bit-index
(movable foldable flushable explicit-check))
;;; FIXME: According to the ANSI spec, it's legal to use any
(defknown deposit-field (integer byte-specifier integer) integer
(movable foldable flushable))
(defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
- (or (float 0.0) (integer 0)) ())
-(defknown make-random-state (&optional (or (member nil t) random-state))
+ (or (float 0.0) (integer 0))
+ (explicit-check))
+(defknown make-random-state (&optional
+ (or (member nil t) random-state unsigned-byte
+ (simple-array (unsigned-byte 8) (*))
+ (simple-array (unsigned-byte 32) (*))))
random-state (flushable))
(defknown random-state-p (t) boolean (movable foldable flushable))
\f
char-lessp char-greaterp char-not-greaterp char-not-lessp)
(character &rest character) boolean (movable foldable flushable))
+(defknown (two-arg-char-equal
+ two-arg-char-not-equal
+ two-arg-char-lessp
+ two-arg-char-not-lessp
+ two-arg-char-greaterp
+ two-arg-char-not-greaterp)
+ (character character) boolean (movable foldable flushable))
+
+(defknown char-equal-constant (character character character)
+ boolean
+ (movable foldable flushable explicit-check))
+
(defknown character (t) character (movable foldable unsafely-flushable))
(defknown char-code (character) char-code (movable foldable flushable))
(defknown (char-upcase char-downcase) (character) character
(defknown 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))
&key
(:initial-element t))
consed-sequence
- (movable unsafe)
+ (movable)
:derive-type (creation-result-type-specifier-nth-arg 1))
(defknown concatenate (type-specifier &rest sequence) consed-sequence
(defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
(defknown %map-to-simple-vector-arity-1 (callable sequence) simple-vector
(flushable call))
-(defknown %map-to-nil-on-simple-vector (callable simple-vector) null
- (flushable call))
-(defknown %map-to-nil-on-vector (callable vector) null (flushable call))
-(defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))
(defknown map-into (sequence callable &rest sequence)
sequence
(defknown (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
- (foldable flushable call unsafe))
+ (foldable flushable call))
-(defknown fill (sequence t &key (:start index) (:end sequence-end)) sequence
- (unsafe)
+(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))
+ :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 ()
:derive-type #'result-type-first-arg
- :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1)
+ :result-arg 0)
(defknown remove
- (t sequence &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
: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
: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)
- (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
- (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
:destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
(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
:destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(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
(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)
- (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)
:derive-type (sequence-result-nth-arg 3)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(defknown remove-duplicates
- (sequence &key (:test callable) (:test-not callable) (:start index)
+ (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
- (sequence &key (:test callable) (:test-not callable) (:start index)
+ (sequence &rest t &key (:test callable) (:test-not callable) (:start index)
(:from-end t) (:end sequence-end) (:key callable))
sequence
(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)
- (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))
-(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)
- (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))
-(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)
- (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)
- (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...
-(defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
+(defknown (stable-sort sort) (sequence callable &rest t &key (:key callable))
+ sequence
(call)
:derive-type (sequence-result-nth-arg 1)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
: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
&key
(:start index)
(:end sequence-end))
sequence
()
- :derive-type (sequence-result-nth-arg 1))
+ :derive-type #'result-type-first-arg)
\f
;;;; from the "Manipulating List Structure" chapter:
(defknown (car cdr first rest)
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 list-length (list) (or index null) (foldable unsafely-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 sb!impl::last1 (list) t (foldable flushable))
-(defknown list (&rest t) list (movable flushable unsafe))
-(defknown list* (t &rest t) t (movable flushable unsafe))
+(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
- (movable flushable unsafe))
+ (movable flushable))
+
+(defknown sb!impl::backq-list (&rest t) list (movable flushable))
+(defknown sb!impl::backq-list* (t &rest t) t (movable flushable))
+(defknown sb!impl::backq-append (&rest t) t (flushable))
+(defknown sb!impl::backq-nconc (&rest t) t ()
+ :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
+(defknown sb!impl::backq-cons (t t) cons (foldable movable flushable))
+(defknown sb!impl::backq-vector (list) simple-vector
+ (foldable movable flushable))
;;; All but last must be of type LIST, but there seems to be no way to
;;; express that in this syntax.
(defknown append (&rest t) t (flushable))
+(defknown sb!impl::append2 (list t) t (flushable))
(defknown copy-list (list) list (flushable))
(defknown copy-alist (list) list (flushable))
:destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown ldiff (list t) list (flushable))
-(defknown (rplaca rplacd) (cons t) list (unsafe)
+(defknown (rplaca rplacd) (cons t) cons ()
:destroyed-constant-args (nth-constant-args 1))
(defknown subst (t t t &key (:key callable) (:test callable)
(:test-not callable))
- t (flushable unsafe call))
+ t (flushable call))
(defknown nsubst (t t t &key (:key callable) (:test callable)
(:test-not callable))
- t (unsafe call)
+ t (call)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(defknown (subst-if subst-if-not)
(t callable t &key (:key callable))
- t (flushable unsafe call))
+ t (flushable call))
(defknown (nsubst-if nsubst-if-not)
(t callable t &key (:key callable))
- t (unsafe call)
+ t (call)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(defknown sublis (list t &key (:key callable) (:test callable)
(:test-not callable))
- t (flushable unsafe call))
+ t (flushable call))
(defknown nsublis (list t &key (:key callable) (:test callable)
(:test-not callable))
- t (flushable unsafe call)
+ t (flushable call)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
(defknown member (t list &key (:key callable) (:test callable)
(defknown adjoin (t list &key (:key callable) (:test callable)
(:test-not callable))
- list (foldable flushable unsafe call))
+ cons (flushable call))
(defknown (union intersection set-difference set-exclusive-or)
(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) cons (movable flushable))
+(defknown pairlis (t t &optional t) list (flushable))
(defknown (rassoc assoc)
(t list &key (:key callable) (:test callable) (:test-not callable))
(defknown (assoc-if-not assoc-if rassoc-if rassoc-if-not)
(callable list &key (:key callable)) list (foldable flushable call))
-(defknown (memq assq) (t list) list (foldable flushable unsafe))
-(defknown delq (t list) list (flushable unsafe)
+(defknown (memq assq) (t list) list (foldable flushable))
+(defknown delq (t list) list (flushable)
:destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
\f
;;;; from the "Hash Tables" chapter:
(&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
- (flushable unsafe))
+ (flushable))
(defknown hash-table-p (t) boolean (movable foldable flushable))
(defknown gethash (t hash-table &optional t) (values t boolean)
- (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
-(defknown sb!impl::gethash2 (t hash-table) (values t boolean)
- (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
+ (flushable)) ; not FOLDABLE, since hash table contents can change
(defknown sb!impl::gethash3 (t hash-table t) (values t boolean)
- (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
-(defknown %puthash (t hash-table t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 2))
+ (flushable)) ; not FOLDABLE, since hash table contents can change
+(defknown %puthash (t hash-table t) t ()
+ :destroyed-constant-args (nth-constant-args 2)
+ :derive-type #'result-type-last-arg)
(defknown remhash (t hash-table) boolean ()
:destroyed-constant-args (nth-constant-args 2))
(defknown maphash (callable hash-table) null (flushable call))
(defknown clrhash (hash-table) hash-table ()
:destroyed-constant-args (nth-constant-args 2))
(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))
-(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))
-(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
- (#-sb-xc-host 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
(:fill-pointer t)
(:displaced-to (or array null))
(:displaced-index-offset index))
- array (flushable unsafe))
+ array (flushable))
-(defknown vector (&rest t) simple-vector (flushable unsafe))
+(defknown vector (&rest t) simple-vector (flushable))
(defknown aref (array &rest index) t (foldable))
(defknown row-major-aref (array index) t (foldable))
(defknown array-has-fill-pointer-p (array) boolean
(movable foldable flushable))
-(defknown fill-pointer (vector) index (foldable unsafely-flushable))
-(defknown vector-push (t vector) (or index null) ()
+(defknown fill-pointer (complex-vector) index
+ (unsafely-flushable explicit-check))
+(defknown vector-push (t complex-vector) (or index null)
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 2))
-(defknown vector-push-extend (t vector &optional index) index ()
+(defknown vector-push-extend (t complex-vector &optional (and index (integer 1))) index
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 2))
-(defknown vector-pop (vector) t ()
+(defknown vector-pop (complex-vector) t
+ (explicit-check)
:destroyed-constant-args (nth-constant-args 1))
;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
(:initial-element t) (:initial-contents t)
(:fill-pointer t) (:displaced-to (or array null))
(:displaced-index-offset index))
- array (unsafe))
+ array ())
; :derive-type 'result-type-arg1) Not even close...
\f
;;;; from the "Strings" chapter:
simple-string (flushable))
(defknown (string-trim string-left-trim string-right-trim)
- (sequence string-designator) simple-string (flushable))
+ (sequence string-designator) string (flushable))
(defknown (string-upcase string-downcase string-capitalize)
(string-designator &key (:start index) (:end sequence-end))
(defknown make-echo-stream (stream stream) stream (flushable))
(defknown make-string-input-stream (string &optional index sequence-end)
stream
- (flushable unsafe))
+ (flushable))
(defknown make-string-output-stream
(&key (:element-type type-specifier))
- stream
+ string-output-stream
(flushable))
(defknown get-output-stream-string (stream) simple-string ())
(defknown streamp (t) boolean (movable foldable flushable))
(defknown stream-element-type (stream) type-specifier
(movable foldable flushable))
+(defknown stream-external-format (stream) t (flushable))
(defknown (output-stream-p input-stream-p) (stream) boolean
(movable foldable flushable))
+(defknown open-stream-p (stream) boolean (flushable))
(defknown close (stream &key (:abort t)) (eql t) ())
+(defknown file-string-length (ansi-stream (or string character))
+ (or unsigned-byte null)
+ (flushable))
\f
;;;; from the "Input/Output" chapter:
(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)
- (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
- (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)
())
(: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)
(any explicit-check)
:derive-type #'result-type-first-arg)
+(defknown (pprint) (t &optional stream-designator) (values)
+ (explicit-check))
+
;;; xxx-TO-STRING functions are not foldable because they depend on
;;; the dynamic environment, the state of the pretty printer dispatch
;;; table, and probably other run-time factors.
(defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
(defknown write-char (character &optional stream-designator) character
- (explicit-check))
+ (explicit-check)
+ :derive-type #'result-type-first-arg)
+
(defknown (write-string write-line)
(string &optional stream-designator &key (:start index) (:end sequence-end))
string
- (explicit-check))
+ (explicit-check)
+ :derive-type #'result-type-first-arg)
(defknown (terpri finish-output force-output clear-output)
(&optional stream-designator) null
(explicit-check))
(defknown write-byte (integer stream) integer
- (explicit-check))
+ (explicit-check)
+ :derive-type #'result-type-first-arg)
;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
(defknown format ((or (member nil t) stream string)
:directory :name
:type :version))
generalized-boolean
- ())
+ (recursive))
+
(defknown pathname-match-p (pathname-designator pathname-designator)
generalized-boolean
())
+
(defknown translate-pathname (pathname-designator
pathname-designator
pathname-designator &key)
(:end sequence-end)
(:junk-allowed t))
(values (or pathname null) sequence-end)
- ())
+ (recursive))
(defknown merge-pathnames
(pathname-designator &optional pathname-designator pathname-version)
pathname
- (unsafely-flushable))
+ ())
(defknown make-pathname
(&key (:defaults pathname-designator)
(defknown pathname-version (pathname-designator)
pathname-version (flushable))
+(defknown pathname= (pathname pathname) boolean (movable foldable flushable))
+
(defknown (namestring file-namestring directory-namestring host-namestring)
(pathname-designator) (or simple-string null)
(unsafely-flushable))
:rename-and-delete :overwrite
:append :supersede nil))
(:if-does-not-exist (member :error :create nil))
- (:external-format keyword))
+ (:external-format external-format-designator))
(or stream null))
(defknown rename-file (pathname-designator filename)
(values pathname pathname pathname))
-(defknown delete-file (pathname-designator) t)
+(defknown delete-file (pathname-designator) (eql t))
(defknown probe-file (pathname-designator) (or pathname null) ())
(defknown file-write-date (pathname-designator) (or unsigned-byte null)
())
&key
(:verbose t)
(:print t)
- (:if-does-not-exist (member :error :create nil))
- (:external-format keyword))
- t)
+ (:if-does-not-exist t)
+ (:external-format external-format-designator))
+ boolean)
-(defknown directory (pathname-designator &key)
+(defknown directory (pathname-designator &key (:resolve-symlinks t))
list ())
\f
;;;; from the "Conditions" chapter:
-(defknown cell-error-name (cell-error) t)
(defknown error (t &rest t) nil)
(defknown cerror (format-control t &rest t) null)
(defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
(defknown method-combination-error (format-control &rest t) *)
(defknown signal (t &rest t) null)
-(defknown simple-condition-format-control (condition)
- format-control)
-(defknown simple-condition-format-arguments (condition)
- list)
(defknown warn (t &rest t) null)
(defknown invoke-debugger (condition) nil)
(defknown break (&optional format-control &rest t) null)
null)
;;; and analogous SBCL extension:
+(defknown sb!impl::%failed-aver (t) nil)
(defknown bug (t &rest t) nil) ; never returns
+
\f
;;;; from the "Miscellaneous" Chapter:
(member t)))
(:verbose t)
(:print t)
- (:external-format keyword)
+ (:external-format external-format-designator)
;; extensions
(:trace-file t)
- (:block-compile t))
+ (:block-compile t)
+ (:emit-cfasl t))
(values (or pathname null) boolean boolean))
+(defknown (compile-file-pathname)
+ (pathname-designator &key (:output-file (or pathname-designator
+ null
+ (member t)))
+ &allow-other-keys)
+ pathname)
+
;; FIXME: consider making (OR CALLABLE CONS) something like
;; EXTENDED-FUNCTION-DESIGNATOR
(defknown disassemble ((or callable cons) &key
(:stream stream) (:use-labels t))
null)
-(defknown fdocumentation (t symbol)
- (or string null)
- (flushable))
-
(defknown describe (t &optional (or stream (member t nil))) (values))
+(defknown function-lambda-expression (function) (values t boolean t))
(defknown inspect (t) (values))
(defknown room (&optional (member t nil :default)) (values))
(defknown ed (&optional (or symbol cons filename))
(defknown apropos (string-designator &optional package-designator t) (values))
(defknown apropos-list (string-designator &optional package-designator t) list
- (flushable))
+ (flushable recursive))
(defknown get-decoded-time ()
(values (integer 0 59) (integer 0 59) (integer 0 23) (integer 1 31)
(defknown (get-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))
+
+(defknown call-with-timing (callable callable &rest t) *
+ (call))
;;; Even though ANSI defines LISP-IMPLEMENTATION-TYPE and
;;; LISP-IMPLEMENTATION-VERSION to possibly punt and return NIL, we
short-site-name long-site-name)
() (or simple-string null) (flushable))
-(defknown identity (t) t (movable foldable flushable unsafe)
+(defknown identity (t) t (movable foldable flushable)
:derive-type #'result-type-first-arg)
(defknown constantly (t) function (movable flushable))
\f
;;;; miscellaneous extensions
+(defknown symbol-global-value (symbol) t ())
+(defknown set-symbol-global-value (symbol t) t ()
+ :derive-type #'result-type-last-arg)
+
(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
+(defknown %rest-values (t t t) * (always-translatable))
+(defknown %rest-ref (t t t t) * (always-translatable))
+(defknown %rest-length (t t t) * (always-translatable))
+(defknown %rest-null (t t t t) * (always-translatable))
+(defknown %rest-true (t t t) * (always-translatable))
+
+(defknown %unary-truncate/single-float (single-float) integer (movable foldable flushable))
+(defknown %unary-truncate/double-float (double-float) integer (movable foldable flushable))
+
;;; We can't fold this in general because of SATISFIES. There is a
;;; special optimizer anyway.
(defknown %typep (t (or type-specifier ctype)) boolean
(movable flushable explicit-check))
(defknown %instance-typep (t (or type-specifier ctype)) boolean
- (movable flushable explicit-check))
+ (movable flushable explicit-check always-translatable))
+;;; We should never emit a call to %typep-wrapper
+(defknown %typep-wrapper (t t (or type-specifier ctype)) t
+ (movable flushable always-translatable))
(defknown %cleanup-point () t)
(defknown %special-bind (t t) 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)
;; FIXME: This function does not return, but due to the implementation
;; of FILTER-LVAR we cannot write it here.
-(defknown %compile-time-type-error (t t t) *)
+(defknown %compile-time-type-error (t t t t) *)
+(defknown sb!kernel::case-failure (t t t) nil)
(defknown %odd-key-args-error () nil)
(defknown %unknown-key-arg-error (t) nil)
(defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer
(movable foldable flushable explicit-check))
(defknown %negate (number) number (movable foldable flushable explicit-check))
-(defknown %check-bound (array index fixnum) index (movable foldable flushable))
+(defknown %check-bound (array index fixnum) index
+ (movable foldable flushable dx-safe))
(defknown data-vector-ref (simple-array index) t
- (foldable explicit-check always-translatable))
+ (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
- (unsafe explicit-check always-translatable))
+ (explicit-check always-translatable))
+(defknown data-vector-set-with-offset (array fixnum fixnum t) t
+ (explicit-check always-translatable))
(defknown hairy-data-vector-ref (array index) t
(foldable explicit-check))
-(defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
-(defknown %caller-frame-and-pc () (values t t) (flushable))
+(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))
-(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 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))
function
(flushable foldable))
+(defknown (%adjoin %adjoin-eq)
+ (t list)
+ list
+ (explicit-check flushable))
+
+(defknown (%member %member-eq
+ %assoc %assoc-eq %rassoc %rassoc-eq)
+ (t list)
+ list
+ (explicit-check foldable flushable))
+
+(defknown (%adjoin-key %adjoin-key-eq)
+ (t list function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-key %member-key-eq
+ %assoc-key %assoc-key-eq %rassoc-key %rassoc-key-eq)
+ (t list function)
+ list
+ (explicit-check foldable flushable call))
+
+(defknown (%assoc-if %assoc-if-not %rassoc-if %rassoc-if-not
+ %member-if %member-if-not)
+ (function list)
+ list
+ (explicit-check foldable flushable call))
+
+(defknown (%assoc-if-key %assoc-if-not-key %rassoc-if-key %rassoc-if-not-key
+ %member-if-key %member-if-not-key)
+ (function list function)
+ list
+ (explicit-check foldable flushable call))
+
+(defknown (%adjoin-test %adjoin-test-not)
+ (t list function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-test %member-test-not
+ %assoc-test %assoc-test-not
+ %rassoc-test %rassoc-test-not)
+ (t list function)
+ list
+ (explicit-check foldable flushable call))
+
+(defknown (%adjoin-key-test %adjoin-key-test-not)
+ (t list function function)
+ list
+ (explicit-check flushable call))
+
+(defknown (%member-key-test %member-key-test-not
+ %assoc-key-test %assoc-key-test-not
+ %rassoc-key-test %rassoc-key-test-not)
+ (t list function function)
+ list
+ (explicit-check foldable flushable call))
+
(defknown %check-vector-sequence-bounds (vector index sequence-end)
index
(unwind))
nil) ; never returns
-(defknown arg-count-error (t t t t t t) nil (unsafe))
+(defknown arg-count-error (t t t t t t) nil ())
\f
;;;; SETF inverses
-(defknown %aset (array &rest t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %set-row-major-aref (array index t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown (%rplaca %rplacd) (cons t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %put (symbol t t) t (unsafe))
-(defknown %setelt (sequence index t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %svset (simple-vector index t) t (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %bitset ((array bit) &rest index) bit (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %sbitset ((simple-array bit) &rest index) bit (unsafe)
- :destroyed-constant-args (nth-constant-args 1))
-(defknown %charset (string index character) character (unsafe)
+(defknown (setf aref) (t array &rest index) t ()
+ :destroyed-constant-args (nth-constant-args 2)
+ :derive-type #'result-type-first-arg)
+(defknown %set-row-major-aref (array index t) t ()
:destroyed-constant-args (nth-constant-args 1))
-(defknown %scharset (simple-string index character) character (unsafe)
+(defknown (%rplaca %rplacd) (cons t) t ()
+ :destroyed-constant-args (nth-constant-args 1)
+ :derive-type #'result-type-last-arg)
+(defknown %put (symbol t t) t ())
+(defknown %setelt (sequence index t) t ()
+ :destroyed-constant-args (nth-constant-args 1)
+ :derive-type #'result-type-last-arg)
+(defknown %svset (simple-vector index t) t ()
:destroyed-constant-args (nth-constant-args 1))
-(defknown %set-symbol-value (symbol t) t (unsafe))
-(defknown (setf symbol-function) (function symbol) function (unsafe))
-(defknown %set-symbol-plist (symbol t) t (unsafe))
-(defknown (setf fdocumentation) ((or string null) t symbol)
- (or string null)
- ())
-(defknown %setnth (unsigned-byte list t) t (unsafe)
+(defknown (setf bit) (bit (array bit) &rest index) bit ()
:destroyed-constant-args (nth-constant-args 2))
-(defknown %set-fill-pointer (vector index) index (unsafe)
+(defknown (setf sbit) (bit (simple-array bit) &rest index) bit ()
+ :destroyed-constant-args (nth-constant-args 2))
+(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 ()
+ :derive-type #'result-type-last-arg)
+(defknown %setnth (unsigned-byte list t) t ()
+ :destroyed-constant-args (nth-constant-args 2)
+ :derive-type #'result-type-last-arg)
+(defknown %set-fill-pointer (complex-vector index) index
+ (explicit-check)
+ :destroyed-constant-args (nth-constant-args 1)
+ :derive-type #'result-type-last-arg)
\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) ())
+;; 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)
;;;; 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-abort compiler-error) (string &rest t) nil ())
-(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(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 (string &rest t) null ())
+(defknown style-warn (t &rest t) null ())
+
+(defknown coerce-to-condition ((or condition symbol string function)
+ list type-specifier symbol)
+ condition
+ (explicit-check))
+
+(defknown sc-number-or-lose (symbol) sc-number
+ (foldable))
+
+;;;; memory barriers
+
+(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))