array.lisp

开源跨平台Lisp编译器

         (:temporary (:scs (non-descriptor-reg)) temp old)
         (:generator 20
           (multiple-value-bind (word extra) (floor index ,elements-per-word)
             ,@(when (eq *backend-byte-order* :big-endian)
                 `((setf extra (logxor extra (1- ,elements-per-word)))))
             (inst lw old object
                   (- (* (+ word vector-data-offset) n-word-bytes)
                      other-pointer-lowtag))
             (unless (and (sc-is value immediate)
                          (= (tn-value value) ,(1- (ash 1 bits))))
               (cond ((= extra ,(1- elements-per-word))
                      (inst sll old ,bits)
                      (inst srl old ,bits))
                     (t
                      (inst li temp
                            (lognot (ash ,(1- (ash 1 bits)) (* extra ,bits))))
                      (inst and old temp))))
             (sc-case value
               (zero)
               (immediate
                (let ((value (ash (logand (tn-value value) ,(1- (ash 1 bits)))
                                  (* extra ,bits))))
                  (cond ((< value #x10000)
                         (inst or old value))
                        (t
                         (inst li temp value)
                         (inst or old temp)))))
               (unsigned-reg
                (inst sll temp value (* extra ,bits))
                (inst or old temp)))
             (inst sw old object
                   (- (* (+ word vector-data-offset) n-word-bytes)
                      other-pointer-lowtag))
             (sc-case value
               (immediate
                (inst li result (tn-value value)))
               (zero
                (move result zero-tn))
               (unsigned-reg
                (move result value))))))))))
  (def-small-data-vector-frobs simple-bit-vector 1)
  (def-small-data-vector-frobs simple-array-unsigned-byte-2 2)
  (def-small-data-vector-frobs simple-array-unsigned-byte-4 4))

;;; And the float variants.
(define-vop (data-vector-ref/simple-array-single-float)
  (:note "inline array access")
  (:translate data-vector-ref)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg)))
  (:arg-types simple-array-single-float positive-fixnum)
  (:results (value :scs (single-reg)))
  (:result-types single-float)
  (:temporary (:scs (interior-reg)) lip)
  (:generator 20
    (inst addu lip object index)
    (inst lwc1 value lip
          (- (* vector-data-offset n-word-bytes)
             other-pointer-lowtag))
    (inst nop)))

(define-vop (data-vector-set/simple-array-single-float)
  (:note "inline array store")
  (:translate data-vector-set)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg))
         (value :scs (single-reg) :target result))
  (:arg-types simple-array-single-float positive-fixnum single-float)
  (:results (result :scs (single-reg)))
  (:result-types single-float)
  (:temporary (:scs (interior-reg)) lip)
  (:generator 20
    (inst addu lip object index)
    (inst swc1 value lip
          (- (* vector-data-offset n-word-bytes)
             other-pointer-lowtag))
    (unless (location= result value)
      (inst fmove :single result value))))

(define-vop (data-vector-ref/simple-array-double-float)
  (:note "inline array access")
  (:translate data-vector-ref)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg)))
  (:arg-types simple-array-double-float positive-fixnum)
  (:results (value :scs (double-reg)))
  (:result-types double-float)
  (:temporary (:scs (interior-reg)) lip)
  (:generator 20
    (inst addu lip object index)
    (inst addu lip index)
    (ecase *backend-byte-order*
      (:big-endian
       (inst lwc1 value lip
             (+ (- (* vector-data-offset n-word-bytes)
                   other-pointer-lowtag)
                n-word-bytes))
       (inst lwc1-odd value lip
             (- (* vector-data-offset n-word-bytes)
                other-pointer-lowtag)))
      (:little-endian
       (inst lwc1 value lip
             (- (* vector-data-offset n-word-bytes)
                other-pointer-lowtag))
       (inst lwc1-odd value lip
             (+ (- (* vector-data-offset n-word-bytes)
                   other-pointer-lowtag)
                n-word-bytes))))
    (inst nop)))

(define-vop (data-vector-set/simple-array-double-float)
  (:note "inline array store")
  (:translate data-vector-set)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg))
         (value :scs (double-reg) :target result))
  (:arg-types simple-array-double-float positive-fixnum double-float)
  (:results (result :scs (double-reg)))
  (:result-types double-float)
  (:temporary (:scs (interior-reg)) lip)
  (:generator 20
    (inst addu lip object index)
    (inst addu lip index)
    (ecase *backend-byte-order*
      (:big-endian
       (inst swc1 value lip
             (+ (- (* vector-data-offset n-word-bytes)
                   other-pointer-lowtag)
                n-word-bytes))
       (inst swc1-odd value lip
             (- (* vector-data-offset n-word-bytes)
                other-pointer-lowtag)))
      (:little-endian
       (inst swc1 value lip
             (- (* vector-data-offset n-word-bytes)
                other-pointer-lowtag))
       (inst swc1-odd value lip
             (+ (- (* vector-data-offset n-word-bytes)
                   other-pointer-lowtag)
                n-word-bytes))))
    (unless (location= result value)
      (inst fmove :double result value))))

;;; Complex float arrays.
(define-vop (data-vector-ref/simple-array-complex-single-float)
  (:note "inline array access")
  (:translate data-vector-ref)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg)))
  (:arg-types simple-array-complex-single-float positive-fixnum)
  (:results (value :scs (complex-single-reg)))
  (:temporary (:scs (interior-reg)) lip)
  (:result-types complex-single-float)
  (:generator 5
    (inst addu lip object index)
    (inst addu lip index)
    (let ((real-tn (complex-single-reg-real-tn value)))
      (inst lwc1 real-tn lip (- (* vector-data-offset n-word-bytes)
                                other-pointer-lowtag)))
    (let ((imag-tn (complex-single-reg-imag-tn value)))
      (inst lwc1 imag-tn lip (- (* (1+ vector-data-offset) n-word-bytes)
                                other-pointer-lowtag)))
    (inst nop)))

(define-vop (data-vector-set/simple-array-complex-single-float)
  (:note "inline array store")
  (:translate data-vector-set)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg))
         (value :scs (complex-single-reg) :target result))
  (:arg-types simple-array-complex-single-float positive-fixnum
              complex-single-float)
  (:results (result :scs (complex-single-reg)))
  (:result-types complex-single-float)
  (:temporary (:scs (interior-reg)) lip)
  (:generator 5
    (inst addu lip object index)
    (inst addu lip index)
    (let ((value-real (complex-single-reg-real-tn value))
          (result-real (complex-single-reg-real-tn result)))
      (inst swc1 value-real lip (- (* vector-data-offset n-word-bytes)
                                   other-pointer-lowtag))
      (unless (location= result-real value-real)
        (inst fmove :single result-real value-real)))
    (let ((value-imag (complex-single-reg-imag-tn value))
          (result-imag (complex-single-reg-imag-tn result)))
      (inst swc1 value-imag lip (- (* (1+ vector-data-offset) n-word-bytes)
                                   other-pointer-lowtag))
      (unless (location= result-imag value-imag)
        (inst fmove :single result-imag value-imag)))))

(define-vop (data-vector-ref/simple-array-complex-double-float)
  (:note "inline array access")
  (:translate data-vector-ref)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg) :target shift))
  (:arg-types simple-array-complex-double-float positive-fixnum)
  (:results (value :scs (complex-double-reg)))
  (:result-types complex-double-float)
  (:temporary (:scs (interior-reg)) lip)
  (:temporary (:scs (any-reg) :from (:argument 1)) shift)
  (:generator 6
    (inst sll shift index n-fixnum-tag-bits)
    (inst addu lip object shift)
    (let ((real-tn (complex-double-reg-real-tn value)))
      (ld-double real-tn lip (- (* vector-data-offset n-word-bytes)
                                other-pointer-lowtag)))
    (let ((imag-tn (complex-double-reg-imag-tn value)))
      (ld-double imag-tn lip (- (* (+ vector-data-offset 2) n-word-bytes)
                                other-pointer-lowtag)))
    (inst nop)))

(define-vop (data-vector-set/simple-array-complex-double-float)
  (:note "inline array store")
  (:translate data-vector-set)
  (:policy :fast-safe)
  (:args (object :scs (descriptor-reg))
         (index :scs (any-reg) :target shift)
         (value :scs (complex-double-reg) :target result))
  (:arg-types simple-array-complex-double-float positive-fixnum
              complex-double-float)
  (:results (result :scs (complex-double-reg)))
  (:result-types complex-double-float)
  (:temporary (:scs (interior-reg)) lip)
  (:temporary (:scs (any-reg) :from (:argument 1)) shift)
  (:generator 6
    (inst sll shift index n-fixnum-tag-bits)
    (inst addu lip object shift)
    (let ((value-real (complex-double-reg-real-tn value))
          (result-real (complex-double-reg-real-tn result)))
      (str-double value-real lip (- (* vector-data-offset n-word-bytes)
                                    other-pointer-lowtag))
      (unless (location= result-real value-real)
        (inst fmove :double result-real value-real)))
    (let ((value-imag (complex-double-reg-imag-tn value))
          (result-imag (complex-double-reg-imag-tn result)))
      (str-double value-imag lip (- (* (+ vector-data-offset 2) n-word-bytes)
                                    other-pointer-lowtag))
      (unless (location= result-imag value-imag)
        (inst fmove :double result-imag value-imag)))))


;;; These vops are useful for accessing the bits of a vector irrespective of
;;; what type of vector it is.
(define-full-reffer raw-bits * 0 other-pointer-lowtag (unsigned-reg) unsigned-num
  %raw-bits)
(define-full-setter set-raw-bits * 0 other-pointer-lowtag (unsigned-reg)
  unsigned-num %set-raw-bits)
(define-full-reffer vector-raw-bits * vector-data-offset other-pointer-lowtag
  (unsigned-reg) unsigned-num %vector-raw-bits)
(define-full-setter set-vector-raw-bits * vector-data-offset other-pointer-lowtag
  (unsigned-reg) unsigned-num %set-vector-raw-bits)

;;;; Misc. Array VOPs.
(define-vop (get-vector-subtype get-header-data))
(define-vop (set-vector-subtype set-header-data))