sun4u/cpu/spitfire_copy.s

5  * Common Development and Distribution License, Version 1.0 only
12  * and limitations under the License.
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
113  *	We've tried to restore fp state from the stack and failed.  To
122  * preserve - the rest of the kernel does not use fp and, anyway, fp
125  *	- userland has fp state and is interrupted (device interrupt
126  *	  or trap) and within the interrupt/trap handling we use
131  *	  userland or in kernel copy) and the tl0 component of the handling
133  *	- a user process with fp state incurs a copy-on-write fault and
137  * using our stack is ideal (and since fp copy cannot be leaf optimized
140  * To make sure that floating point state is always saved and restored
174  * FPUSED_FLAG: The FP registers were in use and must be restored
188  * floating-point register save area and 2 32-bit temp locations.
522 	  and	%l6, BCOPY_FLAG, %l1	! copy flag to %l1
537 	and	%o2, -64, %o2
573 	! and bcopy. kcopy will *always* set a t_lofault handler
575 	! and *not* to invoke any existing error handler. As far as
628  * Assumes double word alignment and a count >= 256.
647         ! kcopy and bcopy use the same code path. If BCOPY_FLAG is set
648         ! and the saved lofault was zero, we won't reset lofault on
682 	 * and (dest & ~63) - (src & ~63) can be 3 blocks even if
740 	and	%o2, -64, %o2
762 	! and memcpy/bcopy have different calling sequences
1500 	and	%l3, 0x4, %l3		! fprs.du = fprs.dl = 0
1513 	  and	%l6, COPY_FLAGS, %l1	! Store flags in %l1
1529 	and	%o2, -64, %o2
1571 	! handler and go home.
1611 	xor	%i0, %i1, %o4		! xor from and to address
1616 	xor	%i0, %i1, %o4		! xor from and to address
1621 	! use aligned reads and writes where possible
1623 	! with odd alignment between source and destnation
1624 	! using word reads and writes with the proper shifts
1625 	! in between to align transfers to and from memory
1643 	! both source and destination addresses are unaligned
1680 	and	%i2, 3, %l4		! must do remaining bytes if count%4 > 0
1700 	! the source address is aligned and destination is not
1718 	and	%i2, 3, %l4		! must do remaining bytes if count%4 > 0
1746 	sub	%i0, %i1, %i0		! i0 gets the difference of src and dst
1748 	! the destination address is aligned and the source is not
1772 	! source and destination are now double-word aligned
1775 	and	%i2, 7, %i2		! unaligned leftover count
1776 	sub	%i0, %i1, %i0		! i0 gets the difference of src and dst
1790 	and	%i2, 3, %i2		! unaligned leftover count
1804 	sub	%i0, %i1, %i0		! i0 gets the difference of src and dst
1811 	sub	%i0, %i1, %i0		! i0 gets difference of src and dst
1815 	! assumes dest in %i1 and (source - dest) in %i0
1835 	! handler and go home.
1855  * Common code used to align transfers on word and doubleword
1856  * boudaries.  Aligns source and destination and returns a count
1891 	subcc	%o0, %o1, %o3		! difference of from and to address
1898 2:	cmp	%o2, %o3		! cmp size and abs(from - to)
1901 	cmp	%o0, %o1		! compare from and to addresses
1936  * has already disabled kernel preemption and has checked
1962 	and	%l1, -64, %l1
2026  * Transfer data to and from user space -
2031  * Note that copyin(9F) and copyout(9F) are part of the
2036  * So there's two extremely similar routines - xcopyin() and xcopyout()
2042  * There are also stub routines for xcopyout_little and xcopyin_little,
2053  * The only difference between default_copy{in,out} and
2094  * and output pointers. Based on the alignment we check count
2103  * to the appropriate copy loop and copy that many chunks.
2107  * done and can go home. If not, we figure out what the largest
2108  * chunk size left to be copied is and branch to that copy loop
2113  * copy but decide to punt and return to the copy loops. There is
2115  * the single byte aligned copy limit and what VIS treats as its
2122  * This routine handles fixing up the stack and general housecleaning.
2125  * for default_copyOP and copyOP_noerr are found at the end of
2185 	and	%o2, -64, %o2
2228 	! Check the length and bail if zero.
2266 	! %o0 and %o2 point at the end and remain pointing at the end
2331 	! We're big enough and copy is on. Do it with HW.
2343 	! If so, go off and do the copy.
2364 	! HW assist is on and we're large enough. Do it.
2406 	! HW assist is on and we're large enough. Do it.
2431 	! HW is on and we're big enough. Do it.
2445 	! and bounce back to a non-HW assisted copy. This dispatches those
2450 	! and do it.
2537 	! We're going to go off and do a block copy.
2538 	! Switch fault hendlers and grab a window. We
2548 	ba,pt	%ncc, .do_block_copyout		! Not in use. Go off and do it.
2560 	! We're going to go off and do a block copy.
2561 	! Change to the heavy duty fault handler and grab a window first.
2572 	and	%o2, -64, %o2
2594 	! and memcpy/bcopy have different calling sequences
3332 	and	%l3, 0x4, %l3		! fprs.du = fprs.dl = 0
3359 	and	%o2, -64, %o2
3482 	! Check the length and bail if zero.
3518 	! %o0 and %o1 point at the end and remain pointing at the end
3571 	! We're big enough and copy is on. Do it with HW.
3660 	! HW assist is on and we're large enough to use it.
3679 	! and bounce back to a non-hw assisted copy. This dispatches
3685 	! and do it.
3777 	! Switch fault hendlers and grab a window. We
3798 	! We're going off and do a block copy.
3799 	! Change to the heavy duty fault handler and grab a window first.
3813 	and	%o2, -64, %o2
3835 	! and memcpy/bcopy have different calling sequences
4572 	and	%l3, 0x4, %l3		! fprs.du = fprs.dl = 0
4598 	and	%o2, -64, %o2
4790  * and returns 1.  Otherwise 0 is returned indicating success.
4791  * Caller is responsible for ensuring use_hw_bzero is true and that
4817 	! ... and must be 256 bytes or more
4822 	! ... and length must be a multiple of 64
4842 	and	%l1, -64, %l1