anchor.diff:  		collect (if (plusp i)
   			    (ash 1 i)
   			    (/ 1 (ash 1 (- i)))))))
  +
  +(defstruct memory-operand
  +  base
  +  offset
  +  direction
  +  mode)
   
   (defun arm-scale=>shift (scale)
     (declare (type (or arm-scale arm-fixnum-scale) scale))
  
positive.code:     (rm :field (byte 4 0) :type 'sb-vm::reg)))
  
  (defun emit-pld (address &optional (segment (sb-assem::%%current-segment%%)))
    (flet ((compute-opcode (direction)
             (if (eq direction :down) #b10101 #b11101)))
      (sb-impl::aver (typep address 'sb-vm::memory-operand))
      (let* ((base      (sb-vm::memory-operand-base      address))
             (offset    (sb-vm::memory-operand-offset    address))
             (direction (sb-vm::memory-operand-direction address))
             (mode      (sb-vm::memory-operand-mode      address))
             (cond-bits #xf))
        (sb-impl::aver (eq mode :offset))
        (cond
          ((integerp offset)
           (sb-impl::aver (typep offset '(unsigned-byte 12)))
           (sb-vm::emit-dp-instruction segment cond-bits #b01 1
                                       (compute-opcode direction)
                                       (sb-c::tn-offset base) #xf
                                       offset))
          (t
           (sb-vm::emit-dp-instruction segment cond-bits #b01 1
                                       (compute-opcode direction)
                                       (sb-c::tn-offset base) #xf
                                       (sb-vm::encode-shifter-operand offset)))))))
    
    
  
  
  
negative.code:    loop8
     (let ((regs (list r0 r1 r2 r3 r4 r5 r8 r10)))
       (emit-ldmia src 8 regs)
       (emit-pld
        (make-memory-operand :base src :offset 256
                             :direction :up :mode :offset))
       (emit-stmia dst 8 regs)
       (sb-assem:inst sub n-words n-words 8))
     loop8-test
  