[linux-2.6-block.git] / arch / sparc / lib / csum_copy.S

/* SPDX-License-Identifier: GPL-2.0 */
/* csum_copy.S: Checksum+copy code for sparc64
 *
 * Copyright (C) 2005 David S. Miller <davem@davemloft.net>
 */

#include <asm/export.h>

#ifdef __KERNEL__
#define GLOBAL_SPARE	%g7
#else
#define GLOBAL_SPARE	%g5
#endif

#ifndef EX_LD
#define EX_LD(x)	x
#endif

#ifndef EX_ST
#define EX_ST(x)	x
#endif

#ifndef EX_RETVAL
#define EX_RETVAL(x)	x
#endif

#ifndef LOAD
#define LOAD(type,addr,dest)	type [addr], dest
#endif

#ifndef STORE
#define STORE(type,src,addr)	type src, [addr]
#endif

#ifndef FUNC_NAME
#define FUNC_NAME	csum_partial_copy_nocheck
#endif

	.register	%g2, #scratch
	.register	%g3, #scratch

	.text

90:
	/* We checked for zero length already, so there must be
	 * at least one byte.
	 */
	be,pt		%icc, 1f
	 nop
	EX_LD(LOAD(ldub, %o0 + 0x00, %o4))
	add		%o0, 1, %o0
	sub		%o2, 1, %o2
	EX_ST(STORE(stb, %o4, %o1 + 0x00))
	add		%o1, 1, %o1
1:	andcc		%o0, 0x2, %g0
	be,pn		%icc, 80f
	 cmp		%o2, 2
	blu,pn		%icc, 60f
	 nop
	EX_LD(LOAD(lduh, %o0 + 0x00, %o5))
	add		%o0, 2, %o0
	sub		%o2, 2, %o2
	EX_ST(STORE(sth, %o5, %o1 + 0x00))
	add		%o1, 2, %o1
	ba,pt		%xcc, 80f
	 add		%o5, %o4, %o4

	.globl		FUNC_NAME
	.type		FUNC_NAME,#function
	EXPORT_SYMBOL(FUNC_NAME)
FUNC_NAME:		/* %o0=src, %o1=dst, %o2=len, %o3=sum */
	LOAD(prefetch, %o0 + 0x000, #n_reads)
	xor		%o0, %o1, %g1
	clr		%o4
	andcc		%g1, 0x3, %g0
	bne,pn		%icc, 95f
	 LOAD(prefetch, %o0 + 0x040, #n_reads)
	
	brz,pn		%o2, 70f
	 andcc		%o0, 0x3, %g0

	/* We "remember" whether the lowest bit in the address
	 * was set in GLOBAL_SPARE.  Because if it is, we have to swap
	 * upper and lower 8 bit fields of the sum we calculate.
	*/
	bne,pn		%icc, 90b
	 andcc		%o0, 0x1, GLOBAL_SPARE

80:
	LOAD(prefetch, %o0 + 0x080, #n_reads)
	andncc		%o2, 0x3f, %g3

	LOAD(prefetch, %o0 + 0x0c0, #n_reads)
	sub		%o2, %g3, %o2
	brz,pn		%g3, 2f
	 LOAD(prefetch, %o0 + 0x100, #n_reads)

	/* So that we don't need to use the non-pairing
	 * add-with-carry instructions we accumulate 32-bit
	 * values into a 64-bit register.  At the end of the
	 * loop we fold it down to 32-bits and so on.
	 */
	ba,pt		%xcc, 1f
	LOAD(prefetch, %o0 + 0x140, #n_reads)

	.align		32
1:	EX_LD(LOAD(lduw, %o0 + 0x00, %o5))
	EX_LD(LOAD(lduw, %o0 + 0x04, %g1))
	EX_LD(LOAD(lduw, %o0 + 0x08, %g2))
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x00))
	EX_LD(LOAD(lduw, %o0 + 0x0c, %o5))
	add		%o4, %g1, %o4
	EX_ST(STORE(stw, %g1, %o1 + 0x04))
	EX_LD(LOAD(lduw, %o0 + 0x10, %g1))
	add		%o4, %g2, %o4
	EX_ST(STORE(stw, %g2, %o1 + 0x08))
	EX_LD(LOAD(lduw, %o0 + 0x14, %g2))
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x0c))
	EX_LD(LOAD(lduw, %o0 + 0x18, %o5))
	add		%o4, %g1, %o4
	EX_ST(STORE(stw, %g1, %o1 + 0x10))
	EX_LD(LOAD(lduw, %o0 + 0x1c, %g1))
	add		%o4, %g2, %o4
	EX_ST(STORE(stw, %g2, %o1 + 0x14))
	EX_LD(LOAD(lduw, %o0 + 0x20, %g2))
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x18))
	EX_LD(LOAD(lduw, %o0 + 0x24, %o5))
	add		%o4, %g1, %o4
	EX_ST(STORE(stw, %g1, %o1 + 0x1c))
	EX_LD(LOAD(lduw, %o0 + 0x28, %g1))
	add		%o4, %g2, %o4
	EX_ST(STORE(stw, %g2, %o1 + 0x20))
	EX_LD(LOAD(lduw, %o0 + 0x2c, %g2))
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x24))
	EX_LD(LOAD(lduw, %o0 + 0x30, %o5))
	add		%o4, %g1, %o4
	EX_ST(STORE(stw, %g1, %o1 + 0x28))
	EX_LD(LOAD(lduw, %o0 + 0x34, %g1))
	add		%o4, %g2, %o4
	EX_ST(STORE(stw, %g2, %o1 + 0x2c))
	EX_LD(LOAD(lduw, %o0 + 0x38, %g2))
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x30))
	EX_LD(LOAD(lduw, %o0 + 0x3c, %o5))
	add		%o4, %g1, %o4
	EX_ST(STORE(stw, %g1, %o1 + 0x34))
	LOAD(prefetch, %o0 + 0x180, #n_reads)
	add		%o4, %g2, %o4
	EX_ST(STORE(stw, %g2, %o1 + 0x38))
	subcc		%g3, 0x40, %g3
	add		%o0, 0x40, %o0
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x3c))
	bne,pt		%icc, 1b
	 add		%o1, 0x40, %o1

2:	and		%o2, 0x3c, %g3
	brz,pn		%g3, 2f
	 sub		%o2, %g3, %o2
1:	EX_LD(LOAD(lduw, %o0 + 0x00, %o5))
	subcc		%g3, 0x4, %g3
	add		%o0, 0x4, %o0
	add		%o4, %o5, %o4
	EX_ST(STORE(stw, %o5, %o1 + 0x00))
	bne,pt		%icc, 1b
	 add		%o1, 0x4, %o1

2:
	/* fold 64-->32 */
	srlx		%o4, 32, %o5
	srl		%o4, 0, %o4
	add		%o4, %o5, %o4
	srlx		%o4, 32, %o5
	srl		%o4, 0, %o4
	add		%o4, %o5, %o4

	/* fold 32-->16 */
	sethi		%hi(0xffff0000), %g1
	srl		%o4, 16, %o5
	andn		%o4, %g1, %g2
	add		%o5, %g2, %o4
	srl		%o4, 16, %o5
	andn		%o4, %g1, %g2
	add		%o5, %g2, %o4

60:
	/* %o4 has the 16-bit sum we have calculated so-far.  */
	cmp		%o2, 2
	blu,pt		%icc, 1f
	 nop
	EX_LD(LOAD(lduh, %o0 + 0x00, %o5))
	sub		%o2, 2, %o2
	add		%o0, 2, %o0
	add		%o4, %o5, %o4
	EX_ST(STORE(sth, %o5, %o1 + 0x00))
	add		%o1, 0x2, %o1
1:	brz,pt		%o2, 1f
	 nop
	EX_LD(LOAD(ldub, %o0 + 0x00, %o5))
	sub		%o2, 1, %o2
	add		%o0, 1, %o0
	EX_ST(STORE(stb, %o5, %o1 + 0x00))
	sllx		%o5, 8, %o5
	add		%o1, 1, %o1
	add		%o4, %o5, %o4
1:
	/* fold 32-->16 */
	sethi		%hi(0xffff0000), %g1
	srl		%o4, 16, %o5
	andn		%o4, %g1, %g2
	add		%o5, %g2, %o4
	srl		%o4, 16, %o5
	andn		%o4, %g1, %g2
	add		%o5, %g2, %o4

1:	brz,pt		GLOBAL_SPARE, 1f
	 nop

	/* We started with an odd byte, byte-swap the result.  */
	srl		%o4, 8, %o5
	and		%o4, 0xff, %g1
	sll		%g1, 8, %g1
	or		%o5, %g1, %o4

1:	addcc		%o3, %o4, %o3
	addc		%g0, %o3, %o3

70:
	retl
	 srl		%o3, 0, %o0

95:	mov		0, GLOBAL_SPARE
	brlez,pn	%o2, 4f
	 andcc		%o0, 1, %o5		
	be,a,pt		%icc, 1f
	 srl		%o2, 1, %g1		
	sub		%o2, 1, %o2	
	EX_LD(LOAD(ldub, %o0, GLOBAL_SPARE))
	add		%o0, 1, %o0	
	EX_ST(STORE(stb, GLOBAL_SPARE, %o1))
	srl		%o2, 1, %g1
	add		%o1, 1, %o1
1:	brz,a,pn	%g1, 3f
	 andcc		%o2, 1, %g0
	andcc		%o0, 2, %g0	
	be,a,pt		%icc, 1f
	 srl		%g1, 1, %g1
	EX_LD(LOAD(lduh, %o0, %o4))
	sub		%o2, 2, %o2	
	srl		%o4, 8, %g2
	sub		%g1, 1, %g1	
	EX_ST(STORE(stb, %g2, %o1))
	add		%o4, GLOBAL_SPARE, GLOBAL_SPARE
	EX_ST(STORE(stb, %o4, %o1 + 1))
	add		%o0, 2, %o0	
	srl		%g1, 1, %g1
	add		%o1, 2, %o1
1:	brz,a,pn	%g1, 2f		
	 andcc		%o2, 2, %g0
	EX_LD(LOAD(lduw, %o0, %o4))
5:	srl		%o4, 24, %g2
	srl		%o4, 16, %g3
	EX_ST(STORE(stb, %g2, %o1))
	srl		%o4, 8, %g2
	EX_ST(STORE(stb, %g3, %o1 + 1))
	add		%o0, 4, %o0
	EX_ST(STORE(stb, %g2, %o1 + 2))
	addcc		%o4, GLOBAL_SPARE, GLOBAL_SPARE
	EX_ST(STORE(stb, %o4, %o1 + 3))
	addc		GLOBAL_SPARE, %g0, GLOBAL_SPARE
	add		%o1, 4, %o1
	subcc		%g1, 1, %g1
	bne,a,pt	%icc, 5b
	 EX_LD(LOAD(lduw, %o0, %o4))
	sll		GLOBAL_SPARE, 16, %g2
	srl		GLOBAL_SPARE, 16, GLOBAL_SPARE
	srl		%g2, 16, %g2
	andcc		%o2, 2, %g0
	add		%g2, GLOBAL_SPARE, GLOBAL_SPARE 
2:	be,a,pt		%icc, 3f		
	 andcc		%o2, 1, %g0
	EX_LD(LOAD(lduh, %o0, %o4))
	andcc		%o2, 1, %g0
	srl		%o4, 8, %g2
	add		%o0, 2, %o0	
	EX_ST(STORE(stb, %g2, %o1))
	add		GLOBAL_SPARE, %o4, GLOBAL_SPARE
	EX_ST(STORE(stb, %o4, %o1 + 1))
	add		%o1, 2, %o1
3:	be,a,pt		%icc, 1f		
	 sll		GLOBAL_SPARE, 16, %o4
	EX_LD(LOAD(ldub, %o0, %g2))
	sll		%g2, 8, %o4	
	EX_ST(STORE(stb, %g2, %o1))
	add		GLOBAL_SPARE, %o4, GLOBAL_SPARE
	sll		GLOBAL_SPARE, 16, %o4
1:	addcc		%o4, GLOBAL_SPARE, GLOBAL_SPARE
	srl		GLOBAL_SPARE, 16, %o4
	addc		%g0, %o4, GLOBAL_SPARE
	brz,pt		%o5, 4f
	 srl		GLOBAL_SPARE, 8, %o4
	and		GLOBAL_SPARE, 0xff, %g2
	and		%o4, 0xff, %o4
	sll		%g2, 8, %g2
	or		%g2, %o4, GLOBAL_SPARE
4:	addcc		%o3, GLOBAL_SPARE, %o3
	addc		%g0, %o3, %o0
	retl
	 srl		%o0, 0, %o0
	.size		FUNC_NAME, .-FUNC_NAME
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4 LT	2	/* csum_copy.S: Checksum+copy code for sparc64
	3	*
	4	* Copyright (C) 2005 David S. Miller <davem@davemloft.net>
	5	*/
	6
d3867f04 AV	7	#include <asm/export.h>
d3867f04 AV	8
1da177e4 LT	9	#ifdef __KERNEL__
	10	#define GLOBAL_SPARE %g7
	11	#else
	12	#define GLOBAL_SPARE %g5
	13	#endif
	14
	15	#ifndef EX_LD
	16	#define EX_LD(x) x
	17	#endif
	18
	19	#ifndef EX_ST
	20	#define EX_ST(x) x
	21	#endif
	22
	23	#ifndef EX_RETVAL
	24	#define EX_RETVAL(x) x
	25	#endif
	26
	27	#ifndef LOAD
	28	#define LOAD(type,addr,dest) type [addr], dest
	29	#endif
	30
	31	#ifndef STORE
	32	#define STORE(type,src,addr) type src, [addr]
	33	#endif
	34
	35	#ifndef FUNC_NAME
	36	#define FUNC_NAME csum_partial_copy_nocheck
	37	#endif
	38
	39	.register %g2, #scratch
	40	.register %g3, #scratch
	41
	42	.text
	43
	44	90:
	45	/* We checked for zero length already, so there must be
	46	* at least one byte.
	47	*/
	48	be,pt %icc, 1f
	49	nop
	50	EX_LD(LOAD(ldub, %o0 + 0x00, %o4))
	51	add %o0, 1, %o0
	52	sub %o2, 1, %o2
	53	EX_ST(STORE(stb, %o4, %o1 + 0x00))
	54	add %o1, 1, %o1
	55	1: andcc %o0, 0x2, %g0
	56	be,pn %icc, 80f
	57	cmp %o2, 2
	58	blu,pn %icc, 60f
	59	nop
	60	EX_LD(LOAD(lduh, %o0 + 0x00, %o5))
	61	add %o0, 2, %o0
	62	sub %o2, 2, %o2
	63	EX_ST(STORE(sth, %o5, %o1 + 0x00))
	64	add %o1, 2, %o1
	65	ba,pt %xcc, 80f
	66	add %o5, %o4, %o4
	67
	68	.globl FUNC_NAME
f5a651f1	69	.type FUNC_NAME,#function
d3867f04	70	EXPORT_SYMBOL(FUNC_NAME)
1da177e4 LT	71	FUNC_NAME: /* %o0=src, %o1=dst, %o2=len, %o3=sum */
	72	LOAD(prefetch, %o0 + 0x000, #n_reads)
	73	xor %o0, %o1, %g1
	74	clr %o4
	75	andcc %g1, 0x3, %g0
	76	bne,pn %icc, 95f
	77	LOAD(prefetch, %o0 + 0x040, #n_reads)
	78
	79	brz,pn %o2, 70f
	80	andcc %o0, 0x3, %g0
	81
	82	/* We "remember" whether the lowest bit in the address
	83	* was set in GLOBAL_SPARE. Because if it is, we have to swap
	84	* upper and lower 8 bit fields of the sum we calculate.
	85	*/
	86	bne,pn %icc, 90b
	87	andcc %o0, 0x1, GLOBAL_SPARE
	88
	89	80:
	90	LOAD(prefetch, %o0 + 0x080, #n_reads)
	91	andncc %o2, 0x3f, %g3
	92
	93	LOAD(prefetch, %o0 + 0x0c0, #n_reads)
	94	sub %o2, %g3, %o2
	95	brz,pn %g3, 2f
	96	LOAD(prefetch, %o0 + 0x100, #n_reads)
	97
	98	/* So that we don't need to use the non-pairing
	99	* add-with-carry instructions we accumulate 32-bit
	100	* values into a 64-bit register. At the end of the
	101	* loop we fold it down to 32-bits and so on.
	102	*/
	103	ba,pt %xcc, 1f
	104	LOAD(prefetch, %o0 + 0x140, #n_reads)
	105
	106	.align 32
	107	1: EX_LD(LOAD(lduw, %o0 + 0x00, %o5))
	108	EX_LD(LOAD(lduw, %o0 + 0x04, %g1))
	109	EX_LD(LOAD(lduw, %o0 + 0x08, %g2))
	110	add %o4, %o5, %o4
	111	EX_ST(STORE(stw, %o5, %o1 + 0x00))
	112	EX_LD(LOAD(lduw, %o0 + 0x0c, %o5))
	113	add %o4, %g1, %o4
	114	EX_ST(STORE(stw, %g1, %o1 + 0x04))
	115	EX_LD(LOAD(lduw, %o0 + 0x10, %g1))
	116	add %o4, %g2, %o4
	117	EX_ST(STORE(stw, %g2, %o1 + 0x08))
	118	EX_LD(LOAD(lduw, %o0 + 0x14, %g2))
	119	add %o4, %o5, %o4
	120	EX_ST(STORE(stw, %o5, %o1 + 0x0c))
	121	EX_LD(LOAD(lduw, %o0 + 0x18, %o5))
	122	add %o4, %g1, %o4
	123	EX_ST(STORE(stw, %g1, %o1 + 0x10))
	124	EX_LD(LOAD(lduw, %o0 + 0x1c, %g1))
	125	add %o4, %g2, %o4
	126	EX_ST(STORE(stw, %g2, %o1 + 0x14))
	127	EX_LD(LOAD(lduw, %o0 + 0x20, %g2))
	128	add %o4, %o5, %o4
	129	EX_ST(STORE(stw, %o5, %o1 + 0x18))
	130	EX_LD(LOAD(lduw, %o0 + 0x24, %o5))
	131	add %o4, %g1, %o4
	132	EX_ST(STORE(stw, %g1, %o1 + 0x1c))
	133	EX_LD(LOAD(lduw, %o0 + 0x28, %g1))
	134	add %o4, %g2, %o4
135	EX_ST(STORE(stw, %g2, %o1 + 0x20))
136	EX_LD(LOAD(lduw, %o0 + 0x2c, %g2))
137	add %o4, %o5, %o4
138	EX_ST(STORE(stw, %o5, %o1 + 0x24))
139	EX_LD(LOAD(lduw, %o0 + 0x30, %o5))
140	add %o4, %g1, %o4
141	EX_ST(STORE(stw, %g1, %o1 + 0x28))
142	EX_LD(LOAD(lduw, %o0 + 0x34, %g1))
143	add %o4, %g2, %o4
144	EX_ST(STORE(stw, %g2, %o1 + 0x2c))
145	EX_LD(LOAD(lduw, %o0 + 0x38, %g2))
146	add %o4, %o5, %o4
147	EX_ST(STORE(stw, %o5, %o1 + 0x30))
148	EX_LD(LOAD(lduw, %o0 + 0x3c, %o5))
149	add %o4, %g1, %o4
150	EX_ST(STORE(stw, %g1, %o1 + 0x34))
151	LOAD(prefetch, %o0 + 0x180, #n_reads)
152	add %o4, %g2, %o4
153	EX_ST(STORE(stw, %g2, %o1 + 0x38))
154	subcc %g3, 0x40, %g3
155	add %o0, 0x40, %o0
156	add %o4, %o5, %o4
157	EX_ST(STORE(stw, %o5, %o1 + 0x3c))
158	bne,pt %icc, 1b
159	add %o1, 0x40, %o1
160
161	2: and %o2, 0x3c, %g3
162	brz,pn %g3, 2f
163	sub %o2, %g3, %o2
164	1: EX_LD(LOAD(lduw, %o0 + 0x00, %o5))
165	subcc %g3, 0x4, %g3
166	add %o0, 0x4, %o0
167	add %o4, %o5, %o4
168	EX_ST(STORE(stw, %o5, %o1 + 0x00))
169	bne,pt %icc, 1b
170	add %o1, 0x4, %o1
171
172	2:
173	/* fold 64-->32 */
174	srlx %o4, 32, %o5
175	srl %o4, 0, %o4
176	add %o4, %o5, %o4
177	srlx %o4, 32, %o5
178	srl %o4, 0, %o4
179	add %o4, %o5, %o4
180
181	/* fold 32-->16 */
182	sethi %hi(0xffff0000), %g1
183	srl %o4, 16, %o5
184	andn %o4, %g1, %g2
185	add %o5, %g2, %o4
186	srl %o4, 16, %o5
187	andn %o4, %g1, %g2
188	add %o5, %g2, %o4
189
190	60:
191	/* %o4 has the 16-bit sum we have calculated so-far. */
192	cmp %o2, 2
193	blu,pt %icc, 1f
194	nop
195	EX_LD(LOAD(lduh, %o0 + 0x00, %o5))
196	sub %o2, 2, %o2
197	add %o0, 2, %o0
198	add %o4, %o5, %o4
199	EX_ST(STORE(sth, %o5, %o1 + 0x00))
200	add %o1, 0x2, %o1
201	1: brz,pt %o2, 1f
202	nop
203	EX_LD(LOAD(ldub, %o0 + 0x00, %o5))
204	sub %o2, 1, %o2
205	add %o0, 1, %o0
206	EX_ST(STORE(stb, %o5, %o1 + 0x00))
207	sllx %o5, 8, %o5
208	add %o1, 1, %o1
209	add %o4, %o5, %o4
210	1:
211	/* fold 32-->16 */
212	sethi %hi(0xffff0000), %g1
213	srl %o4, 16, %o5
214	andn %o4, %g1, %g2
215	add %o5, %g2, %o4
216	srl %o4, 16, %o5
217	andn %o4, %g1, %g2
218	add %o5, %g2, %o4
219
220	1: brz,pt GLOBAL_SPARE, 1f
221	nop
222
223	/* We started with an odd byte, byte-swap the result. */
224	srl %o4, 8, %o5
225	and %o4, 0xff, %g1
226	sll %g1, 8, %g1
227	or %o5, %g1, %o4
228
ae5de0ff DM	229	1: addcc %o3, %o4, %o3
ae5de0ff DM	230	addc %g0, %o3, %o3
1da177e4 LT	231
	232	70:
	233	retl
ae5de0ff	234	srl %o3, 0, %o0
1da177e4 LT	235
	236	95: mov 0, GLOBAL_SPARE
	237	brlez,pn %o2, 4f
	238	andcc %o0, 1, %o5
	239	be,a,pt %icc, 1f
	240	srl %o2, 1, %g1
	241	sub %o2, 1, %o2
	242	EX_LD(LOAD(ldub, %o0, GLOBAL_SPARE))
	243	add %o0, 1, %o0
	244	EX_ST(STORE(stb, GLOBAL_SPARE, %o1))
	245	srl %o2, 1, %g1
	246	add %o1, 1, %o1
	247	1: brz,a,pn %g1, 3f
	248	andcc %o2, 1, %g0
	249	andcc %o0, 2, %g0
	250	be,a,pt %icc, 1f
	251	srl %g1, 1, %g1
	252	EX_LD(LOAD(lduh, %o0, %o4))
	253	sub %o2, 2, %o2
	254	srl %o4, 8, %g2
	255	sub %g1, 1, %g1
	256	EX_ST(STORE(stb, %g2, %o1))
	257	add %o4, GLOBAL_SPARE, GLOBAL_SPARE
	258	EX_ST(STORE(stb, %o4, %o1 + 1))
	259	add %o0, 2, %o0
	260	srl %g1, 1, %g1
	261	add %o1, 2, %o1
	262	1: brz,a,pn %g1, 2f
	263	andcc %o2, 2, %g0
	264	EX_LD(LOAD(lduw, %o0, %o4))
	265	5: srl %o4, 24, %g2
	266	srl %o4, 16, %g3
	267	EX_ST(STORE(stb, %g2, %o1))
	268	srl %o4, 8, %g2
	269	EX_ST(STORE(stb, %g3, %o1 + 1))
	270	add %o0, 4, %o0
	271	EX_ST(STORE(stb, %g2, %o1 + 2))
	272	addcc %o4, GLOBAL_SPARE, GLOBAL_SPARE
	273	EX_ST(STORE(stb, %o4, %o1 + 3))
	274	addc GLOBAL_SPARE, %g0, GLOBAL_SPARE
	275	add %o1, 4, %o1
	276	subcc %g1, 1, %g1
	277	bne,a,pt %icc, 5b
	278	EX_LD(LOAD(lduw, %o0, %o4))
	279	sll GLOBAL_SPARE, 16, %g2
	280	srl GLOBAL_SPARE, 16, GLOBAL_SPARE
	281	srl %g2, 16, %g2
	282	andcc %o2, 2, %g0
	283	add %g2, GLOBAL_SPARE, GLOBAL_SPARE
	284	2: be,a,pt %icc, 3f
	285	andcc %o2, 1, %g0
	286	EX_LD(LOAD(lduh, %o0, %o4))
	287	andcc %o2, 1, %g0
	288	srl %o4, 8, %g2
	289	add %o0, 2, %o0
	290	EX_ST(STORE(stb, %g2, %o1))
	291	add GLOBAL_SPARE, %o4, GLOBAL_SPARE
	292	EX_ST(STORE(stb, %o4, %o1 + 1))
	293	add %o1, 2, %o1
	294	3: be,a,pt %icc, 1f
	295	sll GLOBAL_SPARE, 16, %o4
	296	EX_LD(LOAD(ldub, %o0, %g2))
	297	sll %g2, 8, %o4
	298	EX_ST(STORE(stb, %g2, %o1))
299	add GLOBAL_SPARE, %o4, GLOBAL_SPARE
300	sll GLOBAL_SPARE, 16, %o4
301	1: addcc %o4, GLOBAL_SPARE, GLOBAL_SPARE
302	srl GLOBAL_SPARE, 16, %o4
303	addc %g0, %o4, GLOBAL_SPARE
304	brz,pt %o5, 4f
305	srl GLOBAL_SPARE, 8, %o4
306	and GLOBAL_SPARE, 0xff, %g2
307	and %o4, 0xff, %o4
308	sll %g2, 8, %g2
309	or %g2, %o4, GLOBAL_SPARE
310	4: addcc %o3, GLOBAL_SPARE, %o3
311	addc %g0, %o3, %o0
312	retl
313	srl %o0, 0, %o0
314	.size FUNC_NAME, .-FUNC_NAME