1 ;;;; signatures of machine-specific functions
3 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
14 ;;;; internal type predicates
16 ;;; Simple TYPEP uses that don't have any standard predicate are
17 ;;; translated into non-standard unary predicates.
18 (defknown (fixnump bignump ratiop
19 short-float-p single-float-p double-float-p long-float-p
20 complex-rational-p complex-float-p complex-single-float-p
21 complex-double-float-p
#!+long-float complex-long-float-p
23 base-char-p %standard-char-p %instancep %other-pointer-p
24 base-string-p simple-base-string-p
25 #!+sb-unicode character-string-p
26 #!+sb-unicode simple-character-string-p
28 sequencep extended-sequence-p
29 simple-array-p simple-array-nil-p vector-nil-p
30 simple-array-unsigned-byte-2-p
31 simple-array-unsigned-byte-4-p simple-array-unsigned-byte-7-p
32 simple-array-unsigned-byte-8-p simple-array-unsigned-byte-15-p
33 simple-array-unsigned-byte-16-p
34 #!+#.
(cl:if
(cl:= 32 sb
!vm
:n-word-bits
) '(and) '(or))
35 simple-array-unsigned-byte-29-p
36 simple-array-unsigned-byte-31-p
37 simple-array-unsigned-byte-32-p
38 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
39 simple-array-unsigned-byte-60-p
40 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
41 simple-array-unsigned-byte-63-p
42 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
43 simple-array-unsigned-byte-64-p
44 simple-array-signed-byte-8-p simple-array-signed-byte-16-p
45 #!+#.
(cl:if
(cl:= 32 sb
!vm
:n-word-bits
) '(and) '(or))
46 simple-array-signed-byte-30-p
47 simple-array-signed-byte-32-p
48 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
49 simple-array-signed-byte-61-p
50 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
51 simple-array-signed-byte-64-p
52 simple-array-single-float-p simple-array-double-float-p
53 #!+long-float simple-array-long-float-p
54 simple-array-complex-single-float-p
55 simple-array-complex-double-float-p
56 #!+long-float simple-array-complex-long-float-p
57 system-area-pointer-p realp
58 ;; #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
60 ;; #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
62 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
64 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
66 weak-pointer-p code-component-p lra-p
67 funcallable-instance-p
)
68 (t) boolean
(movable foldable flushable
))
69 (defknown #.
(loop for
(name) in
*vector-without-complex-typecode-infos
*
71 (t) boolean
(movable foldable flushable
))
73 ;;;; miscellaneous "sub-primitives"
75 (defknown pointer-hash
(t) hash
(flushable))
77 (defknown %sp-string-compare
78 (simple-string index index simple-string index index
)
82 (defknown %sxhash-simple-string
(simple-string) hash
85 (defknown %sxhash-simple-substring
(simple-string index
) hash
88 (defknown symbol-hash
(symbol) hash
91 (defknown %set-symbol-hash
(symbol hash
)
94 (defknown initialize-vector
((simple-array * (*)) &rest t
)
96 (always-translatable flushable
)
99 (defknown vector-fill
* (t t t t
) vector
103 (defknown vector-length
(vector) index
(flushable))
105 (defknown vector-sap
((simple-unboxed-array (*))) system-area-pointer
108 (defknown lowtag-of
(t) (unsigned-byte #.sb
!vm
:n-lowtag-bits
)
110 (defknown widetag-of
(t) (unsigned-byte #.sb
!vm
:n-widetag-bits
)
113 (defknown (get-header-data get-closure-length
) (t) (unsigned-byte 24)
115 (defknown set-header-data
(t (unsigned-byte 24)) t
118 (defknown %array-dimension
(t index
) index
120 (defknown %set-array-dimension
(t index index
) index
122 (defknown %array-rank
(t) index
125 (defknown %make-instance
(index) instance
127 (defknown %make-structure-instance
(defstruct-description list
&rest t
) instance
128 (flushable always-translatable
))
129 (defknown %instance-layout
(instance) layout
130 (foldable flushable
))
131 (defknown %set-instance-layout
(instance layout
) layout
133 (defknown %instance-length
(instance) index
134 (foldable flushable
))
135 (defknown %instance-ref
(instance index
) t
136 (flushable always-translatable
))
137 (defknown %instance-set
(instance index t
) t
138 (unsafe always-translatable
))
139 (defknown %layout-invalid-error
(t layout
) nil
)
141 (defknown %raw-instance-ref
/word
(instance index
) sb
!vm
:word
142 (flushable always-translatable
))
143 (defknown %raw-instance-set
/word
(instance index sb
!vm
:word
) sb
!vm
:word
144 (unsafe always-translatable
))
145 (defknown %raw-instance-ref
/single
(instance index
) single-float
146 (flushable always-translatable
))
147 (defknown %raw-instance-set
/single
(instance index single-float
) single-float
148 (unsafe always-translatable
))
149 (defknown %raw-instance-ref
/double
(instance index
) double-float
150 (flushable always-translatable
))
151 (defknown %raw-instance-set
/double
(instance index double-float
) double-float
152 (unsafe always-translatable
))
153 (defknown %raw-instance-ref
/complex-single
(instance index
)
154 (complex single-float
)
155 (flushable always-translatable
))
156 (defknown %raw-instance-set
/complex-single
157 (instance index
(complex single-float
))
158 (complex single-float
)
159 (unsafe always-translatable
))
160 (defknown %raw-instance-ref
/complex-double
(instance index
)
161 (complex double-float
)
162 (flushable always-translatable
))
163 (defknown %raw-instance-set
/complex-double
164 (instance index
(complex double-float
))
165 (complex double-float
)
166 (unsafe always-translatable
))
169 (defknown %raw-instance-atomic-incf
/word
(instance index sb
!vm
:signed-word
) sb
!vm
:word
170 (unsafe always-translatable
))
172 ;;; These two are mostly used for bit-bashing operations.
173 (defknown %vector-raw-bits
(t fixnum
) sb
!vm
:word
175 (defknown (%set-vector-raw-bits
) (t fixnum sb
!vm
:word
) sb
!vm
:word
179 (defknown allocate-vector
((unsigned-byte 8) index index
) (simple-array * (*))
182 (defknown make-array-header
((unsigned-byte 8) (unsigned-byte 24)) array
186 (defknown make-weak-pointer
(t) weak-pointer
189 (defknown %make-complex
(real real
) complex
191 (defknown %make-ratio
(rational rational
) ratio
193 (defknown make-value-cell
(t) t
198 (defknown sse-pack-p
(t) boolean
(foldable flushable
))
199 (defknown %make-sse-pack
((unsigned-byte 64) (unsigned-byte 64))
201 (defknown (%sse-pack-low %sse-pack-high
) (sse-pack)
206 #!+(and sb-lutex sb-thread
)
208 (defknown sb
!vm
::%make-lutex
() sb
!vm
::lutex
())
209 (defknown sb
!vm
::lutexp
(t) boolean
(foldable flushable
)))
211 (defknown (dynamic-space-free-pointer binding-stack-pointer-sap
212 control-stack-pointer-sap
) ()
216 ;;;; debugger support
218 (defknown current-sp
() system-area-pointer
(movable flushable
))
219 (defknown current-fp
() system-area-pointer
(movable flushable
))
220 (defknown stack-ref
(system-area-pointer index
) t
(flushable))
221 (defknown %set-stack-ref
(system-area-pointer index t
) t
(unsafe))
222 (defknown lra-code-header
(t) t
(movable flushable
))
223 (defknown fun-code-header
(t) t
(movable flushable
))
224 (defknown %make-lisp-obj
(sb!vm
:word
) t
(movable flushable
))
225 (defknown get-lisp-obj-address
(t) sb
!vm
:word
(movable flushable
))
226 (defknown fun-word-offset
(function) index
(movable flushable
))
228 ;;;; 32-bit logical operations
230 (defknown word-logical-not
(sb!vm
:word
) sb
!vm
:word
231 (foldable flushable movable
))
233 (defknown (word-logical-and word-logical-nand
234 word-logical-or word-logical-nor
235 word-logical-xor word-logical-eqv
236 word-logical-andc1 word-logical-andc2
237 word-logical-orc1 word-logical-orc2
)
238 (sb!vm
:word sb
!vm
:word
) sb
!vm
:word
239 (foldable flushable movable
))
241 (defknown (shift-towards-start shift-towards-end
) (sb!vm
:word fixnum
)
243 (foldable flushable movable
))
245 ;;;; bignum operations
247 (defknown %allocate-bignum
(bignum-index) bignum-type
250 (defknown %bignum-length
(bignum-type) bignum-index
251 (foldable flushable movable
))
253 (defknown %bignum-set-length
(bignum-type bignum-index
) bignum-type
256 (defknown %bignum-ref
(bignum-type bignum-index
) bignum-element-type
259 (defknown %bignum-ref-with-offset
(bignum-type bignum-index
(signed-byte 24))
260 bignum-element-type
(flushable always-translatable
))
262 (defknown %bignum-set
(bignum-type bignum-index bignum-element-type
)
266 (defknown %bignum-set-with-offset
267 (bignum-type bignum-index
(signed-byte 24) bignum-element-type
)
268 bignum-element-type
(unsafe always-translatable
))
270 (defknown %digit-0-or-plusp
(bignum-element-type) boolean
271 (foldable flushable movable
))
273 (defknown (%add-with-carry %subtract-with-borrow
)
274 (bignum-element-type bignum-element-type
(mod 2))
275 (values bignum-element-type
(mod 2))
276 (foldable flushable movable
))
278 (defknown %multiply-and-add
279 (bignum-element-type bignum-element-type bignum-element-type
280 &optional bignum-element-type
)
281 (values bignum-element-type bignum-element-type
)
282 (foldable flushable movable
))
284 (defknown %multiply
(bignum-element-type bignum-element-type
)
285 (values bignum-element-type bignum-element-type
)
286 (foldable flushable movable
))
288 (defknown %lognot
(bignum-element-type) bignum-element-type
289 (foldable flushable movable
))
291 (defknown (%logand %logior %logxor
) (bignum-element-type bignum-element-type
)
293 (foldable flushable movable
))
295 (defknown %fixnum-to-digit
(fixnum) bignum-element-type
296 (foldable flushable movable
))
298 (defknown %floor
(bignum-element-type bignum-element-type bignum-element-type
)
299 (values bignum-element-type bignum-element-type
)
300 (foldable flushable movable
))
302 (defknown %fixnum-digit-with-correct-sign
(bignum-element-type)
303 (signed-byte #.sb
!vm
:n-word-bits
)
304 (foldable flushable movable
))
306 (defknown (%ashl %ashr %digit-logical-shift-right
)
307 (bignum-element-type (mod #.sb
!vm
:n-word-bits
)) bignum-element-type
308 (foldable flushable movable
))
310 ;;;; bit-bashing routines
312 ;;; FIXME: there's some ugly duplication between the (INTERN (FORMAT ...))
313 ;;; magic here and the same magic in src/code/bit-bash.lisp. I don't know
314 ;;; of any good way to clean it up, but it's definitely violating OAOO.
315 (macrolet ((define-known-copiers ()
317 ,@(loop for i
= 1 then
(* i
2)
318 collect
`(defknown ,(intern (format nil
"UB~D-BASH-COPY" i
)
319 (find-package "SB!KERNEL"))
320 ((simple-unboxed-array (*)) index
(simple-unboxed-array (*)) index index
)
323 collect
`(defknown ,(intern (format nil
"SYSTEM-AREA-UB~D-COPY" i
)
324 (find-package "SB!KERNEL"))
325 (system-area-pointer index system-area-pointer index index
)
328 collect
`(defknown ,(intern (format nil
"COPY-UB~D-TO-SYSTEM-AREA" i
)
329 (find-package "SB!KERNEL"))
330 ((simple-unboxed-array (*)) index system-area-pointer index index
)
333 collect
`(defknown ,(intern (format nil
"COPY-UB~D-FROM-SYSTEM-AREA" i
)
334 (find-package "SB!KERNEL"))
335 (system-area-pointer index
(simple-unboxed-array (*)) index index
)
338 until
(= i sb
!vm
:n-word-bits
)))))
339 (define-known-copiers))
341 ;;; (not really a bit-bashing routine, but starting to take over from
342 ;;; bit-bashing routines in byte-sized copies as of sbcl-0.6.12.29:)
344 ((or (simple-unboxed-array (*)) system-area-pointer
) index
345 (or (simple-unboxed-array (*)) system-area-pointer
) index index
)
349 ;;;; code/function/fdefn object manipulation routines
351 (defknown code-instructions
(t) system-area-pointer
(flushable movable
))
352 (defknown code-header-ref
(t index
) t
(flushable))
353 (defknown code-header-set
(t index t
) t
())
355 (defknown fun-subtype
(function) (unsigned-byte #.sb
!vm
:n-widetag-bits
)
357 (defknown ((setf fun-subtype
))
358 ((unsigned-byte #.sb
!vm
:n-widetag-bits
) function
)
359 (unsigned-byte #.sb
!vm
:n-widetag-bits
)
362 (defknown make-fdefn
(t) fdefn
(flushable movable
))
363 (defknown fdefn-p
(t) boolean
(movable foldable flushable
))
364 (defknown fdefn-name
(fdefn) t
(foldable flushable
))
365 (defknown fdefn-fun
(fdefn) (or function null
) (flushable))
366 (defknown (setf fdefn-fun
) (function fdefn
) t
(unsafe))
367 (defknown fdefn-makunbound
(fdefn) t
())
369 (defknown %simple-fun-self
(function) function
371 (defknown (setf %simple-fun-self
) (function function
) function
374 (defknown %closure-fun
(function) function
377 (defknown %closure-index-ref
(function index
) t
380 (defknown %make-funcallable-instance
(index) function
383 (defknown %funcallable-instance-info
(function index
) t
(flushable))
384 (defknown %set-funcallable-instance-info
(function index t
) t
(unsafe))
386 ;;;; mutator accessors
388 (defknown mutator-self
() system-area-pointer
(flushable movable
))
390 (defknown %data-vector-and-index
(array index
)
391 (values (simple-array * (*)) index
)
392 (foldable flushable
))