X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=9fadaf96acd0d64ff0e6dec16a0004463da336ec;hb=12b1dae1a1ed90c6ffe4d958f1281c1c04a8e89b;hp=68036a2963aa0a89a468a1a5a828953b8ca821c7;hpb=1479483c5f40fc470053da0fc5cd8e42fc77676e;p=sbcl.git diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp index 68036a2..9fadaf9 100644 --- a/src/compiler/fndb.lisp +++ b/src/compiler/fndb.lisp @@ -16,9 +16,9 @@ ;;;; 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. ) @@ -29,8 +29,8 @@ ;;; 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)) ;;;; from the "Predicates" chapter: @@ -76,17 +76,22 @@ (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)) + ;;;; 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 ;;;; from the "Control Structure" chapter: @@ -106,18 +111,18 @@ (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) *) @@ -134,7 +139,7 @@ ;;; We let VALUES-LIST be foldable, since constant-folding will turn ;;; it into VALUES. VALUES is not foldable, since MV constants are ;;; represented by a call to VALUES. -(defknown values (&rest t) * (movable flushable unsafe)) +(defknown values (&rest t) * (movable flushable)) (defknown values-list (list) * (movable foldable unsafely-flushable)) ;;;; from the "Macros" chapter: @@ -142,7 +147,8 @@ (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) @@ -156,7 +162,6 @@ ;;;; 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)) @@ -204,7 +209,7 @@ (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)) @@ -231,7 +236,7 @@ (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)) @@ -256,7 +261,7 @@ (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 @@ -314,8 +319,19 @@ (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 @@ -326,18 +342,18 @@ (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)) @@ -359,6 +375,10 @@ (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 @@ -380,8 +400,12 @@ (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)) @@ -397,6 +421,18 @@ 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 @@ -429,7 +465,7 @@ (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)) @@ -442,13 +478,18 @@ &key (:initial-element t)) consed-sequence - (movable unsafe) + (movable) :derive-type (creation-result-type-specifier-nth-arg 1)) (defknown concatenate (type-specifier &rest sequence) consed-sequence () :derive-type (creation-result-type-specifier-nth-arg 1)) +(defknown %concatenate-to-string (&rest sequence) simple-string + (explicit-check flushable)) +(defknown %concatenate-to-base-string (&rest sequence) simple-base-string + (explicit-check flushable)) + (defknown (map %map) (type-specifier callable sequence &rest sequence) consed-sequence (call) @@ -457,10 +498,6 @@ (defknown %map-to-list-arity-1 (callable sequence) list (flushable call)) (defknown %map-to-simple-vector-arity-1 (callable sequence) simple-vector (flushable call)) -(defknown %map-to-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 @@ -475,36 +512,27 @@ (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 @@ -512,7 +540,7 @@ :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 @@ -520,21 +548,21 @@ :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 @@ -543,7 +571,7 @@ :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 @@ -552,82 +580,82 @@ :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)) @@ -646,7 +674,6 @@ :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) @@ -660,7 +687,7 @@ (:end sequence-end)) sequence () - :derive-type (sequence-result-nth-arg 1)) + :derive-type #'result-type-first-arg) ;;;; from the "Manipulating List Structure" chapter: (defknown (car cdr first rest) @@ -680,7 +707,7 @@ 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)) @@ -688,16 +715,31 @@ (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)) @@ -719,31 +761,31 @@ :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) @@ -756,7 +798,7 @@ (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)) @@ -774,8 +816,8 @@ 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)) @@ -783,8 +825,8 @@ (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)) ;;;; from the "Hash Tables" chapter: @@ -793,32 +835,34 @@ (&key (:test callable) (:size unsigned-byte) (:rehash-size (or (integer 1) (float (1.0)))) (:rehash-threshold (real 0 1)) - (:weakness (member nil :key :value :key-and-value :key-or-value))) + (: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)) ;;;; from the "Arrays" chapter @@ -831,9 +875,9 @@ (: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)) @@ -872,12 +916,16 @@ (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 @@ -888,7 +936,7 @@ (: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... ;;;; from the "Strings" chapter: @@ -915,7 +963,7 @@ 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)) @@ -956,18 +1004,23 @@ (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)) ;;;; from the "Input/Output" chapter: @@ -984,17 +1037,17 @@ (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) ()) @@ -1086,7 +1139,8 @@ (: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) @@ -1096,6 +1150,9 @@ (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. @@ -1111,11 +1168,14 @@ (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 @@ -1125,7 +1185,8 @@ (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) @@ -1149,10 +1210,12 @@ :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) @@ -1177,7 +1240,7 @@ (:end sequence-end) (:junk-allowed t)) (values (or pathname null) sequence-end) - ()) + (recursive)) (defknown merge-pathnames (pathname-designator &optional pathname-designator pathname-version) @@ -1214,6 +1277,8 @@ (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)) @@ -1232,12 +1297,12 @@ :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) ()) @@ -1254,25 +1319,20 @@ &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 ()) ;;;; 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) @@ -1289,7 +1349,9 @@ null) ;;; and analogous SBCL extension: +(defknown sb!impl::%failed-aver (t) nil) (defknown bug (t &rest t) nil) ; never returns + ;;;; from the "Miscellaneous" Chapter: @@ -1307,24 +1369,29 @@ (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)) @@ -1333,7 +1400,7 @@ (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) @@ -1357,7 +1424,10 @@ (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 @@ -1374,7 +1444,7 @@ 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)) @@ -1382,25 +1452,37 @@ ;;;; 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)) ;;;; 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) @@ -1408,6 +1490,10 @@ (defknown %listify-rest-args (t index) list (flushable)) (defknown %more-arg-context (t t) (values t index) (flushable)) (defknown %more-arg (t index) t) +#!+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) @@ -1427,7 +1513,8 @@ ;; 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) @@ -1436,22 +1523,37 @@ (defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer (movable foldable flushable explicit-check)) (defknown %negate (number) number (movable foldable flushable explicit-check)) -(defknown %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)) @@ -1467,6 +1569,64 @@ 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)) @@ -1479,46 +1639,50 @@ 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 ()) ;;;; 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) ;;;; 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) @@ -1536,14 +1700,47 @@ ;;;; 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))