(defconstant unit-bits n-word-bits)
;;; the maximum number of bits that can be dealt with in a single call
-(defconstant max-bits (ash most-positive-fixnum -2))
+(defconstant max-bits (ash sb!xc:most-positive-fixnum -2))
(deftype unit ()
`(unsigned-byte ,unit-bits))
(macrolet ((def (name &rest args)
`(defun ,name ,args
(,name ,@args))))
- (def 32bit-logical-not x)
- (def 32bit-logical-and x y)
- (def 32bit-logical-or x y)
- (def 32bit-logical-xor x y)
- (def 32bit-logical-nor x y)
- (def 32bit-logical-eqv x y)
- (def 32bit-logical-nand x y)
- (def 32bit-logical-andc1 x y)
- (def 32bit-logical-andc2 x y)
- (def 32bit-logical-orc1 x y)
- (def 32bit-logical-orc2 x y))
+ (def word-logical-not x)
+ (def word-logical-and x y)
+ (def word-logical-or x y)
+ (def word-logical-xor x y)
+ (def word-logical-nor x y)
+ (def word-logical-eqv x y)
+ (def word-logical-nand x y)
+ (def word-logical-andc1 x y)
+ (def word-logical-andc2 x y)
+ (def word-logical-orc1 x y)
+ (def word-logical-orc2 x y))
;;; Shift NUMBER by the low-order bits of COUNTOID, adding zero bits
;;; at the "end" and removing bits from the "start". On big-endian
(type index offset)
(values system-area-pointer index))
(let ((address (sap-int sap)))
- (values (int-sap #!-alpha (32bit-logical-andc2 address 3)
+ (values (int-sap #!-alpha (word-logical-andc2 address 3)
#!+alpha (ash (ash address -2) 2))
(+ (* (logand address 3) n-byte-bits) offset))))
(let ((mask (shift-towards-end (start-mask length)
dst-bit-offset)))
(declare (type unit mask))
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2
(funcall dst-ref-fn dst dst-word-offset)
mask))))))
(let ((interior (floor (- length final-bits) unit-bits)))
(let ((mask (end-mask (- dst-bit-offset))))
(declare (type unit mask))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2
(funcall dst-ref-fn dst dst-word-offset)
mask))))
(incf dst-word-offset))
(let ((mask (start-mask final-bits)))
(declare (type unit mask))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2
(funcall dst-ref-fn dst dst-word-offset)
mask)))))))))
(values))
(funcall dst-set-fn dst dst-word-offset
(if (zerop src-bit-offset)
(funcall src-ref-fn src src-word-offset)
- (32bit-logical-or
+ (word-logical-or
(shift-towards-start
(funcall src-ref-fn src src-word-offset)
src-bit-offset)
;; the first word.
(let ((src-bit-shift (- src-bit-offset dst-bit-offset)))
(if (> (+ src-bit-offset length) unit-bits)
- (32bit-logical-or
+ (word-logical-or
(shift-towards-start
(funcall src-ref-fn src src-word-offset)
src-bit-shift)
(declare (type unit mask orig value))
;; Replace the dst word.
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask)))))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask)))))))
((= src-bit-offset dst-bit-offset)
;; The source and dst are aligned, so we don't need to shift
;; anything. But we have to pick the direction of the loop in
(value (funcall src-ref-fn src src-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask))))
+ (word-logical-or (word-logical-and value mask)
+ (word-logical-andc2 orig mask))))
(incf src-word-offset)
(incf dst-word-offset))
;; Just copy the interior words.
(value (funcall src-ref-fn src src-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask))))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask))))))
(t
;; We need to loop from right to left.
(incf dst-word-offset words)
(value (funcall src-ref-fn src src-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask)))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask)))))
(dotimes (i interior)
(decf src-word-offset)
(decf dst-word-offset)
(value (funcall src-ref-fn src src-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask))))))))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask))))))))))
(t
;; They aren't aligned.
(multiple-value-bind (words final-bits)
(get-next-src))
(let ((mask (end-mask (- dst-bit-offset)))
(orig (funcall dst-ref-fn dst dst-word-offset))
- (value (32bit-logical-or
+ (value (word-logical-or
(shift-towards-start prev src-shift)
(shift-towards-end next (- src-shift)))))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask)))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask)))
(incf dst-word-offset)))
(dotimes (i interior)
(get-next-src)
- (let ((value (32bit-logical-or
+ (let ((value (word-logical-or
(shift-towards-end next (- src-shift))
(shift-towards-start prev src-shift))))
(declare (type unit value))
(if (> (+ final-bits src-shift) unit-bits)
(progn
(get-next-src)
- (32bit-logical-or
+ (word-logical-or
(shift-towards-end next (- src-shift))
(shift-towards-start prev src-shift)))
(shift-towards-start next src-shift)))
(orig (funcall dst-ref-fn dst dst-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask))))))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask))))))))
(t
;; We need to loop from right to left.
(incf dst-word-offset words)
(unless (zerop final-bits)
(when (> final-bits (- unit-bits src-shift))
(get-next-src))
- (let ((value (32bit-logical-or
+ (let ((value (word-logical-or
(shift-towards-end next (- src-shift))
(shift-towards-start prev src-shift)))
(mask (start-mask final-bits))
(orig (funcall dst-ref-fn dst dst-word-offset)))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask)))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask)))))
(decf dst-word-offset)
(dotimes (i interior)
(get-next-src)
- (let ((value (32bit-logical-or
+ (let ((value (word-logical-or
(shift-towards-end next (- src-shift))
(shift-towards-start prev src-shift))))
(declare (type unit value))
(setf next prev prev 0))
(let ((mask (end-mask (- dst-bit-offset)))
(orig (funcall dst-ref-fn dst dst-word-offset))
- (value (32bit-logical-or
+ (value (word-logical-or
(shift-towards-start prev src-shift)
(shift-towards-end next (- src-shift)))))
(declare (type unit mask orig value))
(funcall dst-set-fn dst dst-word-offset
- (32bit-logical-or
- (32bit-logical-and value mask)
- (32bit-logical-andc2 orig mask)))))))))))))))
+ (word-logical-or
+ (word-logical-and value mask)
+ (word-logical-andc2 orig mask)))))))))))))))
(values))
\f
;;;; the actual bashers
;; package CL, and shadowing it would be too ugly; so maybe SB!VM:VMBYTE?
;; (And then N-BYTE-BITS would be N-VMBYTE-BITS and so forth?)
(declare (type (simple-array (unsigned-byte 8) 1) bv))
- (declare (type sap sap))
+ (declare (type system-area-pointer sap))
(declare (type fixnum offset))
;; FIXME: Actually it looks as though this, and most other calls to
;; COPY-TO-SYSTEM-AREA, could be written more concisely with