X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ffndb.lisp;h=66d8f46833e778f1c63eb7484289442bec9e278d;hb=89b82a03269446741ab4b7bba8656d6e37502fe9;hp=2641b48e154ba0be96198c2654091b5f1c3d226c;hpb=43caa89c20c70fdef77797fe31e6fd09bfcf2527;p=sbcl.git

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 2641b48..66d8f46 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:
 
@@ -81,7 +81,7 @@
 
 (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 find-classoid (name-for-class &optional t)
   (or classoid null) ())
 (defknown classoid-of (t) classoid (flushable))
 (defknown layout-of (t) layout (flushable))
@@ -164,6 +164,7 @@
 (defknown get-properties (list list) (values t t list) (foldable flushable))
 (defknown symbol-name (symbol) simple-string (movable foldable flushable))
 (defknown make-symbol (string) symbol (flushable))
+(defknown %make-symbol (simple-string) symbol (flushable))
 (defknown copy-symbol (symbol &optional t) symbol (flushable))
 (defknown gensym (&optional (or string unsigned-byte)) symbol ())
 (defknown symbol-package (symbol) (or sb!xc:package null) (flushable))
@@ -203,7 +204,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))
@@ -230,7 +231,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))
 
@@ -433,7 +434,7 @@
 (defknown reverse (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))
 
-(defknown nreverse (sequence) sequence ()
+(defknown nreverse (sequence) sequence (important-result)
   :derive-type #'result-type-first-arg
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
 
@@ -475,35 +476,27 @@
   (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))
 
-(defknown fill (sequence t &key (:start index) (:end sequence-end)) sequence
+(defknown fill (sequence t &rest t &key
+                         (:start index) (:end sequence-end)) sequence
   (unsafe)
   :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
@@ -511,7 +504,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
@@ -519,30 +512,30 @@
   :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
-  (flushable call)
+  (flushable call important-result)
   :derive-type (sequence-result-nth-arg 2)
   :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
@@ -551,85 +544,88 @@
   :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)
+  (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)
+  (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))
+(defknown sb!impl::stable-sort-list (list function function) list
+  (call important-result)
+  :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
 (defknown sb!impl::sort-vector (vector index index function (or function null))
   * ; SORT-VECTOR works through side-effect
   (call)
@@ -638,7 +634,7 @@
 (defknown merge (type-specifier sequence sequence callable
                                 &key (:key callable))
   sequence
-  (call)
+  (call important-result)
   :derive-type (creation-result-type-specifier-nth-arg 1)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 2 3))
 
@@ -684,8 +680,13 @@
 (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 %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 unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list
@@ -708,7 +709,7 @@
 (defknown sb!impl::nconc2 (list t) t ()
   :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
 
-(defknown nreconc (list t) t ()
+(defknown nreconc (list t) t (important-result)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
 (defknown butlast (list &optional unsigned-byte) list (flushable))
 (defknown nbutlast (list &optional unsigned-byte) list ()
@@ -762,7 +763,7 @@
 (defknown (nunion nintersection nset-difference nset-exclusive-or)
   (list list &key (:key callable) (:test callable) (:test-not callable))
   list
-  (foldable flushable call)
+  (foldable flushable call important-result)
   :destroyed-constant-args (nth-constant-nonempty-sequence-args 1 2))
 
 (defknown subsetp
@@ -789,7 +790,9 @@
   (&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))
 (defknown hash-table-p (t) boolean (movable foldable flushable))
@@ -807,14 +810,14 @@
 (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))
 
 ;;;; from the "Arrays" chapter
 
@@ -871,12 +874,15 @@
 (defknown fill-pointer (vector) index (foldable unsafely-flushable))
 (defknown vector-push (t vector) (or index null) ()
   :destroyed-constant-args (nth-constant-args 2))
-(defknown vector-push-extend (t vector &optional index) index ()
+(defknown vector-push-extend (t vector &optional (and index (integer 1)))
+  index ()
   :destroyed-constant-args (nth-constant-args 2))
 (defknown vector-pop (vector) t ()
   :destroyed-constant-args (nth-constant-args 1))
 
 ;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
+;;; Also, an important-result warning could be provided if the array
+;;; is known to be not expressly adjustable.
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
          (:initial-element t) (:initial-contents t)
@@ -909,7 +915,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))
@@ -975,10 +981,10 @@
 (defknown readtablep (t) boolean (movable foldable flushable))
 
 (defknown set-syntax-from-char
-  (character character &optional (or readtable null) readtable) (eql t)
+  (character character &optional readtable (or readtable null)) (eql t)
   ())
 
-(defknown set-macro-character (character callable &optional t readtable)
+(defknown set-macro-character (character callable &optional t (or readtable null))
   (eql t)
   (unsafe))
 (defknown get-macro-character (character &optional (or readtable null))
@@ -987,7 +993,7 @@
 (defknown make-dispatch-macro-character (character &optional t readtable)
   (eql t) ())
 (defknown set-dispatch-macro-character
-  (character character callable &optional readtable) function
+  (character character callable &optional (or readtable null)) (eql t)
   (unsafe))
 (defknown get-dispatch-macro-character
   (character character &optional (or readtable null)) (or callable null)
@@ -1159,7 +1165,7 @@
 (defknown load-logical-pathname-translations (string) t ())
 (defknown logical-pathname-translations (logical-host-designator) list ())
 
-(defknown pathname (pathname-designator) pathname (unsafely-flushable))
+(defknown pathname (pathname-designator) pathname ())
 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
@@ -1176,7 +1182,7 @@
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
   pathname
-  (unsafely-flushable))
+  ())
 
 (defknown make-pathname
  (&key (:defaults pathname-designator)
@@ -1248,11 +1254,11 @@
    &key
    (:verbose t)
    (:print t)
-   (:if-does-not-exist (member :error :create nil))
+   (:if-does-not-exist t)
    (:external-format keyword))
   t)
 
-(defknown directory (pathname-designator &key)
+(defknown directory (pathname-designator &key (:resolve-symlinks t))
   list ())
 
 ;;;; from the "Conditions" chapter:
@@ -1314,10 +1320,6 @@
                        (: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 inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))
@@ -1376,19 +1378,18 @@
 
 ;;;; miscellaneous extensions
 
+(defknown symbol-global-value (symbol) t ())
+(defknown set-symbol-global-value (symbol t) t ())
+
 (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)
 
 ;;;; magical compiler frobs
 
+(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
@@ -1402,6 +1403,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)
@@ -1432,19 +1437,34 @@
 (defknown %negate (number) number (movable foldable flushable explicit-check))
 (defknown %check-bound (array index fixnum) index (movable foldable flushable))
 (defknown data-vector-ref (simple-array index) t
-  (foldable explicit-check))
-(defknown data-vector-set (array index t) t (unsafe explicit-check))
+  (foldable explicit-check always-translatable))
+(defknown data-vector-ref-with-offset (simple-array index fixnum) t
+  (foldable explicit-check always-translatable))
+(defknown data-vector-set (array index t) t
+  (unsafe explicit-check always-translatable))
+(defknown data-vector-set-with-offset (array index fixnum t) t
+  (unsafe 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-ref/check-bounds (array index) t
+  (foldable explicit-check))
+(defknown hairy-data-vector-set/check-bounds (array index t)
+  t
+  (unsafe 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 %with-array-data/fp (array index (or index null))
+  (values (simple-array * (*)) index index index)
+  (foldable flushable))
 (defknown %set-symbol-package (symbol t) t (unsafe))
 (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))
@@ -1460,6 +1480,15 @@
   function
   (flushable foldable))
 
+(defknown %adjoin     (t list)          list (explicit-check foldable flushable))
+(defknown %adjoin-key (t list function) list (explicit-check foldable flushable call))
+(defknown %assoc      (t list)          list (explicit-check foldable flushable))
+(defknown %assoc-key  (t list function) list (explicit-check foldable flushable call))
+(defknown %member     (t list)          list (explicit-check foldable flushable))
+(defknown %member-key (t list function) list (explicit-check foldable flushable call))
+(defknown %rassoc     (t list)          list (explicit-check foldable flushable))
+(defknown %rassoc-key (t list function) list (explicit-check foldable flushable call))
+
 (defknown %check-vector-sequence-bounds (vector index sequence-end)
   index
   (unwind))
@@ -1497,10 +1526,7 @@
   :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 %set-symbol-plist (symbol list) list (unsafe))
 (defknown %setnth (unsigned-byte list t) t (unsafe)
   :destroyed-constant-args (nth-constant-args 2))
 (defknown %set-fill-pointer (vector index) index (unsafe)
@@ -1508,10 +1534,10 @@
 
 ;;;; 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)
+    (unsafe always-translatable))
 
 #!+linkage-table
 (defknown foreign-symbol-dataref-sap (simple-string)
@@ -1534,10 +1560,17 @@
 (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 ())
+
+;;;; atomic ops
+(defknown %compare-and-swap-svref (simple-vector index t t) t
+    (unsafe))
+(defknown %compare-and-swap-instance-ref (instance index t t) t
+    (unsafe))
+(defknown %compare-and-swap-symbol-value (symbol t t) t
+    (unsafe unwind))