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 vector-t-p weak-pointer-p code-component-p lra-p
67 funcallable-instance-p
)
68 (t) boolean
(movable foldable flushable
))
70 ;;;; miscellaneous "sub-primitives"
72 (defknown pointer-hash
(t) hash
(flushable))
74 (defknown %sp-string-compare
75 (simple-string index index simple-string index index
)
79 (defknown %sxhash-simple-string
(simple-string) index
82 (defknown %sxhash-simple-substring
(simple-string index
) index
85 (defknown symbol-hash
(symbol) (integer 0 #.sb
!xc
:most-positive-fixnum
)
88 (defknown %set-symbol-hash
(symbol (integer 0 #.sb
!xc
:most-positive-fixnum
))
91 (defknown vector-length
(vector) index
(flushable))
93 (defknown vector-sap
((simple-unboxed-array (*))) system-area-pointer
96 (defknown lowtag-of
(t) (unsigned-byte #.sb
!vm
:n-lowtag-bits
)
98 (defknown widetag-of
(t) (unsigned-byte #.sb
!vm
:n-widetag-bits
)
101 (defknown (get-header-data get-closure-length
) (t) (unsigned-byte 24)
103 (defknown set-header-data
(t (unsigned-byte 24)) t
106 (defknown %array-dimension
(t index
) index
108 (defknown %set-array-dimension
(t index index
) index
110 (defknown %array-rank
(t) index
113 (defknown %make-instance
(index) instance
115 (defknown %make-structure-instance
(defstruct-description list
&rest t
) instance
116 (flushable always-translatable
))
117 (defknown %instance-layout
(instance) layout
118 (foldable flushable
))
119 (defknown %set-instance-layout
(instance layout
) layout
121 (defknown %instance-length
(instance) index
122 (foldable flushable
))
123 (defknown %instance-ref
(instance index
) t
124 (flushable always-translatable
))
125 (defknown %instance-set
(instance index t
) t
126 (unsafe always-translatable
))
127 (defknown %layout-invalid-error
(t layout
) nil
)
131 (defknown %raw-instance-ref
/word
(instance index
) sb
!vm
:word
132 (flushable always-translatable
))
133 (defknown %raw-instance-set
/word
(instance index sb
!vm
:word
) sb
!vm
:word
134 (unsafe always-translatable
))
135 (defknown %raw-instance-ref
/single
(instance index
) single-float
136 (flushable always-translatable
))
137 (defknown %raw-instance-set
/single
(instance index single-float
) single-float
138 (unsafe always-translatable
))
139 (defknown %raw-instance-ref
/double
(instance index
) double-float
140 (flushable always-translatable
))
141 (defknown %raw-instance-set
/double
(instance index double-float
) double-float
142 (unsafe always-translatable
))
143 (defknown %raw-instance-ref
/complex-single
(instance index
)
144 (complex single-float
)
145 (flushable always-translatable
))
146 (defknown %raw-instance-set
/complex-single
147 (instance index
(complex single-float
))
148 (complex single-float
)
149 (unsafe always-translatable
))
150 (defknown %raw-instance-ref
/complex-double
(instance index
)
151 (complex double-float
)
152 (flushable always-translatable
))
153 (defknown %raw-instance-set
/complex-double
154 (instance index
(complex double-float
))
155 (complex double-float
)
156 (unsafe always-translatable
))
159 ;;; %RAW-{REF,SET}-FOO VOPs should be declared as taking a RAW-VECTOR
160 ;;; as their first argument (clarity and to match these DEFKNOWNs).
161 ;;; We declare RAW-VECTOR as a primitive type so the VOP machinery
162 ;;; will accept our VOPs as legitimate. --njf, 2004-08-10
164 ;;; These are only used on HPPA, since on HPPA implements raw slots in
165 ;;; structures with an indirection vector; all other ports implement
166 ;;; raw slots directly in the structure. --njf, 2006-06-02
169 (sb!xc
:deftype raw-vector
() '(simple-array sb
!vm
:word
(*)))
171 (sb!vm
::!def-primitive-type-alias raw-vector
172 #!+#.
(cl:if
(cl:= 32 sb
!vm
:n-word-bits
) '(and) '(or))
173 sb
!vm
::simple-array-unsigned-byte-32
174 #!+#.
(cl:if
(cl:= 64 sb
!vm
:n-word-bits
) '(and) '(or))
175 sb
!vm
::simple-array-unsigned-byte-64
)
177 (defknown %raw-ref-single
(raw-vector index
) single-float
178 (foldable flushable always-translatable
))
179 (defknown %raw-ref-double
(raw-vector index
) double-float
180 (foldable flushable always-translatable
))
182 (defknown %raw-ref-long
(raw-vector index
) long-float
183 (foldable flushable always-translatable
))
184 (defknown %raw-set-single
(raw-vector index single-float
) single-float
185 (unsafe always-translatable
))
186 (defknown %raw-set-double
(raw-vector index double-float
) double-float
187 (unsafe always-translatable
))
189 (defknown %raw-set-long
(raw-vector index long-float
) long-float
190 (unsafe always-translatable
))
192 (defknown %raw-ref-complex-single
(raw-vector index
) (complex single-float
)
193 (foldable flushable always-translatable
))
194 (defknown %raw-ref-complex-double
(raw-vector index
) (complex double-float
)
195 (foldable flushable always-translatable
))
197 (defknown %raw-set-complex-single
(raw-vector index
(complex single-float
))
198 (complex single-float
)
199 (unsafe always-translatable
))
200 (defknown %raw-set-complex-double
(raw-vector index
(complex double-float
))
201 (complex double-float
)
202 (unsafe always-translatable
))
205 (defknown %raw-bits
(t fixnum
) sb
!vm
:word
206 (foldable flushable
))
208 (defknown %raw-bits-with-offset
(t fixnum fixnum
) sb
!vm
:word
209 (flushable always-translatable
))
210 (defknown (%set-raw-bits
) (t fixnum sb
!vm
:word
) sb
!vm
:word
213 (defknown (%set-raw-bits-with-offset
) (t fixnum fixnum sb
!vm
:word
) sb
!vm
:word
214 (unsafe always-translatable
))
215 ;;; These two are mostly used for bit-bashing operations.
216 (defknown %vector-raw-bits
(t fixnum
) sb
!vm
:word
218 (defknown (%set-vector-raw-bits
) (t fixnum sb
!vm
:word
) sb
!vm
:word
222 (defknown allocate-vector
((unsigned-byte 8) index index
) (simple-array * (*))
225 (defknown make-array-header
((unsigned-byte 8) (unsigned-byte 24)) array
229 (defknown make-weak-pointer
(t) weak-pointer
232 (defknown %make-complex
(real real
) complex
234 (defknown %make-ratio
(rational rational
) ratio
236 (defknown make-value-cell
(t) t
241 #!+(and sb-lutex sb-thread
)
243 (defknown sb
!vm
::%make-lutex
() sb
!vm
::lutex
())
244 (defknown sb
!vm
::lutexp
(t) boolean
(foldable flushable
)))
246 (defknown (dynamic-space-free-pointer binding-stack-pointer-sap
247 control-stack-pointer-sap
) ()
251 ;;;; debugger support
253 (defknown current-sp
() system-area-pointer
(movable flushable
))
254 (defknown current-fp
() system-area-pointer
(movable flushable
))
255 (defknown stack-ref
(system-area-pointer index
) t
(flushable))
256 (defknown %set-stack-ref
(system-area-pointer index t
) t
(unsafe))
257 (defknown lra-code-header
(t) t
(movable flushable
))
258 (defknown fun-code-header
(t) t
(movable flushable
))
259 (defknown %make-lisp-obj
(sb!vm
:word
) t
(movable flushable
))
260 (defknown get-lisp-obj-address
(t) sb
!vm
:word
(movable flushable
))
261 (defknown fun-word-offset
(function) index
(movable flushable
))
263 ;;;; 32-bit logical operations
265 (defknown merge-bits
((unsigned-byte 5) sb
!vm
:word sb
!vm
:word
)
267 (foldable flushable movable
))
269 (defknown word-logical-not
(sb!vm
:word
) sb
!vm
:word
270 (foldable flushable movable
))
272 (defknown (word-logical-and word-logical-nand
273 word-logical-or word-logical-nor
274 word-logical-xor word-logical-eqv
275 word-logical-andc1 word-logical-andc2
276 word-logical-orc1 word-logical-orc2
)
277 (sb!vm
:word sb
!vm
:word
) sb
!vm
:word
278 (foldable flushable movable
))
280 (defknown (shift-towards-start shift-towards-end
) (sb!vm
:word fixnum
)
282 (foldable flushable movable
))
284 ;;;; bignum operations
286 (defknown %allocate-bignum
(bignum-index) bignum-type
289 (defknown %bignum-length
(bignum-type) bignum-index
290 (foldable flushable movable
))
292 (defknown %bignum-set-length
(bignum-type bignum-index
) bignum-type
295 (defknown %bignum-ref
(bignum-type bignum-index
) bignum-element-type
298 (defknown %bignum-ref-with-offset
(bignum-type bignum-index
(signed-byte 24))
299 bignum-element-type
(flushable always-translatable
))
301 (defknown %bignum-set
(bignum-type bignum-index bignum-element-type
)
305 (defknown %bignum-set-with-offset
306 (bignum-type bignum-index
(signed-byte 24) bignum-element-type
)
307 bignum-element-type
(unsafe always-translatable
))
309 (defknown %digit-0-or-plusp
(bignum-element-type) boolean
310 (foldable flushable movable
))
312 (defknown (%add-with-carry %subtract-with-borrow
)
313 (bignum-element-type bignum-element-type
(mod 2))
314 (values bignum-element-type
(mod 2))
315 (foldable flushable movable
))
317 (defknown %multiply-and-add
318 (bignum-element-type bignum-element-type bignum-element-type
319 &optional bignum-element-type
)
320 (values bignum-element-type bignum-element-type
)
321 (foldable flushable movable
))
323 (defknown %multiply
(bignum-element-type bignum-element-type
)
324 (values bignum-element-type bignum-element-type
)
325 (foldable flushable movable
))
327 (defknown %lognot
(bignum-element-type) bignum-element-type
328 (foldable flushable movable
))
330 (defknown (%logand %logior %logxor
) (bignum-element-type bignum-element-type
)
332 (foldable flushable movable
))
334 (defknown %fixnum-to-digit
(fixnum) bignum-element-type
335 (foldable flushable movable
))
337 (defknown %floor
(bignum-element-type bignum-element-type bignum-element-type
)
338 (values bignum-element-type bignum-element-type
)
339 (foldable flushable movable
))
341 (defknown %fixnum-digit-with-correct-sign
(bignum-element-type)
342 (signed-byte #.sb
!vm
:n-word-bits
)
343 (foldable flushable movable
))
345 (defknown (%ashl %ashr %digit-logical-shift-right
)
346 (bignum-element-type (mod #.sb
!vm
:n-word-bits
)) bignum-element-type
347 (foldable flushable movable
))
349 ;;;; bit-bashing routines
351 ;;; FIXME: there's some ugly duplication between the (INTERN (FORMAT ...))
352 ;;; magic here and the same magic in src/code/bit-bash.lisp. I don't know
353 ;;; of any good way to clean it up, but it's definitely violating OAOO.
354 (macrolet ((define-known-copiers ()
356 ,@(loop for i
= 1 then
(* i
2)
357 collect
`(defknown ,(intern (format nil
"UB~D-BASH-COPY" i
)
358 (find-package "SB!KERNEL"))
359 ((simple-unboxed-array (*)) index
(simple-unboxed-array (*)) index index
)
362 collect
`(defknown ,(intern (format nil
"SYSTEM-AREA-UB~D-COPY" i
)
363 (find-package "SB!KERNEL"))
364 (system-area-pointer index system-area-pointer index index
)
367 collect
`(defknown ,(intern (format nil
"COPY-UB~D-TO-SYSTEM-AREA" i
)
368 (find-package "SB!KERNEL"))
369 ((simple-unboxed-array (*)) index system-area-pointer index index
)
372 collect
`(defknown ,(intern (format nil
"COPY-UB~D-FROM-SYSTEM-AREA" i
)
373 (find-package "SB!KERNEL"))
374 (system-area-pointer index
(simple-unboxed-array (*)) index index
)
377 until
(= i sb
!vm
:n-word-bits
)))))
378 (define-known-copiers))
380 ;;; (not really a bit-bashing routine, but starting to take over from
381 ;;; bit-bashing routines in byte-sized copies as of sbcl-0.6.12.29:)
383 ((or (simple-unboxed-array (*)) system-area-pointer
) index
384 (or (simple-unboxed-array (*)) system-area-pointer
) index index
)
388 ;;;; code/function/fdefn object manipulation routines
390 (defknown code-instructions
(t) system-area-pointer
(flushable movable
))
391 (defknown code-header-ref
(t index
) t
(flushable))
392 (defknown code-header-set
(t index t
) t
())
394 (defknown fun-subtype
(function) (unsigned-byte #.sb
!vm
:n-widetag-bits
)
396 (defknown ((setf fun-subtype
))
397 ((unsigned-byte #.sb
!vm
:n-widetag-bits
) function
)
398 (unsigned-byte #.sb
!vm
:n-widetag-bits
)
401 (defknown make-fdefn
(t) fdefn
(flushable movable
))
402 (defknown fdefn-p
(t) boolean
(movable foldable flushable
))
403 (defknown fdefn-name
(fdefn) t
(foldable flushable
))
404 (defknown fdefn-fun
(fdefn) (or function null
) (flushable))
405 (defknown (setf fdefn-fun
) (function fdefn
) t
(unsafe))
406 (defknown fdefn-makunbound
(fdefn) t
())
408 (defknown %simple-fun-self
(function) function
410 (defknown (setf %simple-fun-self
) (function function
) function
413 (defknown %closure-fun
(function) function
416 (defknown %closure-index-ref
(function index
) t
419 (defknown %make-funcallable-instance
(index) function
422 (defknown %funcallable-instance-info
(function index
) t
(flushable))
423 (defknown %set-funcallable-instance-info
(function index t
) t
(unsafe))
425 ;;;; mutator accessors
427 (defknown mutator-self
() system-area-pointer
(flushable movable
))
429 (defknown %data-vector-and-index
(array index
)
430 (values (simple-array * (*)) index
)
431 (foldable flushable
))