/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * strcpy(s1, s2)

 *

 * Copy string s2 to s1.  s1 must be large enough. Return s1.

 *

 * Fast assembler language version of the following C-program strcpy

 * which represents the `standard' for the C-library.

 *

 *	char *

 *	strcpy(s1, s2)

 *	register char *s1;

 *	register const char *s2;

 *	{

 *		char *os1 = s1;

 *	

 *		while(*s1++ = *s2++)

 *			;

 *		return(os1);

 *	}

 *

 */

#include <sys/asm_linkage.h>

	! This implementation of strcpy works by first checking the

	! source alignment and copying byte, half byte, or word

	! quantities until the source ptr is aligned at an extended

	! word boundary.  Once this has occurred, the string is copied,

	! checking for zero bytes, depending upon its dst ptr alignment.

	! (methods for xword, word, half-word, and byte copies are present)

	ENTRY(strcpy)

	.align 32

	sub	%o1, %o0, %o3		! src - dst

	andcc	%o1, 7, %o4		! dword aligned ?

	bz,pn	%ncc, .srcaligned	! yup

	mov	%o0, %o2		! save dst

.chkbyte:

	andcc	%o1, 1, %g0		! need to copy byte ?

	bz,pn	%ncc, .chkhalfword	! nope, maybe halfword

	sub	%g0, %o1, %g1		! %g1<2:0> = # of unaligned bytes

	ldub	[%o2 + %o3], %o5	! src[0]

	tst	%o5			! src[0] == 0 ?

	stb	%o5, [%o2]		! dst[0] = src[0]

	bz,pn	%ncc, .done		! yup, done

	inc	%o2			! src++, dst++

.chkhalfword:

	andcc	%g1, 2, %g0		! need to copy half-word ?

	bz,pn	%ncc, .chkword		! nope, maybe word

	nop				! 

	lduh	[%o2 + %o3], %o5	! load src halfword

	srl	%o5, 8, %o4		! extract first byte

	tst	%o4			! first byte == 0 ?

	bz,pn	%ncc, .done		! yup, done

	stb	%o4, [%o2]		! store first byte

	andcc	%o5, 0xff, %g0		! extract second byte

	stb 	%o5, [%o2 + 1]		! store second byte

	bz,pn	%ncc, .done		! yup, 2nd byte zero, done

	add	%o2, 2, %o2		! src += 2

.chkword:

	andcc	%g1, 4, %g0		! need to copy word ?

	bz,pn	%ncc, .srcaligned	! nope

	nop				! 

	lduw	[%o2 + %o3], %o5	! load src word

	srl	%o5, 24, %o4		! extract first byte

	tst	%o4			! is first byte zero ?

	bz,pn	%ncc, .done		! yup, done

	stb	%o4, [%o2]		! store first byte

	srl	%o5, 16, %o4		! extract second byte

	andcc	%o4, 0xff, %g0		! is second byte zero ?

	bz,pn	%ncc, .done		! yup, done

	stb	%o4, [%o2 + 1]		! store second byte

	srl	%o5, 8, %o4		! extract third byte

	andcc	%o4, 0xff, %g0		! third byte zero ?

	bz,pn	%ncc, .done		! yup, done

	stb	%o4, [%o2 + 2]		! store third byte

	andcc	%o5, 0xff, %g0		! fourth byte zero ?

	stb 	%o5, [%o2 + 3]		! store fourth byte

	bz,pn	%ncc, .done		! yup, fourth byte zero, done

	add	%o2, 4, %o2		! src += 2

.srcaligned:	

	sethi	%hi(0x01010101), %o4	! Alan Mycroft's magic1

	or	%o4, %lo(0x01010101),%o4!  finish loading magic1

	sllx	%o4, 32, %o1		! spread magic1

	and	%o2, 3, %g4		! dst<1:0> to examine offset

	or	%o4, %o1, %o4		!   to all 64 bits

	cmp	%g4, 1			! dst offset of 1 or 5

	sllx	%o4, 7, %o5		!  Alan Mycroft's magic2

	be,pn	%ncc, .storebyte1241	! store 1, 2, 4, 1 bytes

	cmp	%g4, 3			! dst offset of 3 or 7

	be,pn	%ncc, .storebyte1421	! store 1, 4, 2, 1 bytes

	cmp	%g4, 2			! dst halfword aligned ?

	be,pn	%ncc, .storehalfword	! yup, store half-word wise

	andcc	%o2, 7, %g0		! dst word aligned ?

	bnz,pn	%ncc, .storeword2	! yup, store word wise

	.empty	

.storedword:

	ldx	[%o2 + %o3], %o1	! src dword

	add	%o2, 8, %o2		! src += 8, dst += 8

	andn	%o5, %o1, %g1		! ~dword & 0x8080808080808080

	sub	%o1, %o4, %g4		! dword - 0x0101010101010101

	andcc	%g4, %g1, %g0		! ((dword - 0x0101010101010101) & ~dword & 0x8080808080808080)

	bz,a,pt	%ncc, .storedword	! no zero byte if magic expression == 0

	stx	%o1, [%o2 - 8]		! store word to dst (address pre-incremented)

.zerobyte:

	orn	%o4, %g0, %o4		! 0xffffffffffffffff

	sllx	%o4, 56, %o4		! 0xff00000000000000

	srlx	%o1, 56, %o3		! %o3<7:0> = first byte

	andcc	%o1, %o4, %g0		! first byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 8]		! store first byte  

	srlx	%o4, 8, %o4		! 0x00ff000000000000

	srlx	%o1, 48, %o3		! %o3<7:0> = second byte

	andcc	%o1, %o4, %g0		! second byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 7]		! store second byte  

	srlx	%o4, 8, %o4		! 0x0000ff0000000000

	srlx	%o1, 40, %o3		! %o3<7:0> = third byte

	andcc	%o1, %o4, %g0		! third byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 6]		! store third byte  

	srlx	%o4, 8, %o4		! 0x000000ff00000000

	srlx	%o1, 32, %o3		! %o3<7:0> = fourth byte

	andcc	%o1, %o4, %g0		! fourth byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 5]		! store fourth byte  

	srlx	%o4, 8, %o4		! 0x00000000ff000000

	srlx	%o1, 24, %o3		! %o3<7:0> = fifth byte

	andcc	%o1, %o4, %g0		! fifth byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 4]		! store fifth byte  

	srlx	%o4, 8, %o4		! 0x0000000000ff0000

	srlx	%o1, 16, %o3		! %o3<7:0> = sixth byte    

	andcc	%o1, %o4, %g0		! sixth byte zero?

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 3]		! store sixth byte

	srlx	%o4, 8, %o4		! 0x000000000000ff00

	andcc	%o1, %o4, %g0		! seventh byte zero?

	srlx	%o1, 8, %o3		! %o3<7:0> = seventh byte

	bz,pn	%ncc, .done		! yup, done

	stb	%o3, [%o2 - 2]		! store seventh byte

	stb	%o1, [%o2 - 1]		! store eigth byte

.done:

	retl				! done with leaf function

	nop				! ensure following loop 16-byte aligned

.storebyte1421:

	ldx	[%o2 + %o3], %o1	! x = src[]

	add	%o2, 8, %o2		! src += 8, dst += 8

	andn	%o5, %o1, %g1		! ~x & 0x8080808080808080

	sub	%o1, %o4, %g4		! x - 0x0101010101010101

	andcc	%g4, %g1, %g0		! ((x - 0x0101010101010101) & ~x & 0x8080808080808080)

	bnz,pn	%ncc, .zerobyte		! x has zero byte, handle end cases

	srlx	%o1, 56, %g1		! %g1<7:0> = first byte; word aligned now

	stb	%g1, [%o2 - 8]		! store first byte

	srlx	%o1, 24, %g1		! %g1<31:0> = bytes 2, 3, 4, 5

	stw	%g1, [%o2 - 7]		! store bytes 2, 3, 4, 5

	srlx	%o1, 8, %g1		! %g1<15:0> = bytes 6, 7

	sth	%g1, [%o2 - 3]		! store bytes 6, 7

	ba	.storebyte1421		! next dword

	stb	%o1, [%o2 - 1]		! store eigth byte

	nop				! ensure following loop 16-byte aligned

	nop				! ensure following loop 16-byte aligned

.storebyte1241:

	ldx	[%o2 + %o3], %o1	! x = src[]

	add	%o2, 8, %o2		! src += 8, dst += 8

	andn	%o5, %o1, %g1		! ~x & 0x8080808080808080

	sub	%o1, %o4, %g4		! x - 0x0101010101010101

	andcc	%g4, %g1, %g0		! ((x - 0x0101010101010101) & ~x & 0x8080808080808080)

	bnz,pn	%ncc, .zerobyte		! x has zero byte, handle end cases

	srlx	%o1, 56, %g1		! %g1<7:0> = first byte; word aligned now

	stb	%g1, [%o2 - 8]		! store first byte

	srlx	%o1, 40, %g1		! %g1<15:0> = bytes 2, 3

	sth	%g1, [%o2 - 7]		! store bytes 2, 3

	srlx	%o1, 8, %g1		! %g1<31:0> = bytes 4, 5, 6, 7

	stw	%g1, [%o2 - 5]		! store bytes 4, 5, 6, 7

	ba	.storebyte1241		! next dword

	stb	%o1, [%o2 - 1]		! store eigth byte

	nop				! ensure following loop 16-byte aligned

	nop				! ensure following loop 16-byte aligned

.storehalfword:

	ldx	[%o2 + %o3], %o1	! x = src[]

	add	%o2, 8, %o2		! src += 8, dst += 8

	andn	%o5, %o1, %g1		! ~x & 0x8080808080808080

	sub	%o1, %o4, %g4		! x - 0x0101010101010101

	andcc	%g4, %g1, %g0		! ((x - 0x0101010101010101) & ~x & 0x8080808080808080)

	bnz,pn	%ncc, .zerobyte		! x has zero byte, handle end cases

	srlx	%o1, 48, %g1		! get first and second byte

	sth	%g1, [%o2 - 8]		! store first and second byte; word aligned now

	srlx	%o1, 16, %g1		! %g1<31:0> = bytes 3, 4, 5, 6	

	stw	%g1, [%o2 - 6]		! store bytes 3, 4, 5, 6

	ba	.storehalfword		! next word

	sth	%o1, [%o2 - 2]		! store seventh and eigth byte

.storeword:

	ldx	[%o2 + %o3], %o1	! x = src[]

.storeword2:

	add	%o2, 8, %o2		! src += 8, dst += 8

	andn	%o5, %o1, %g1		! ~x & 0x0x8080808080808080

	sub	%o1, %o4, %g4		! x - 0x0101010101010101

	andcc	%g4, %g1, %g0		! ((x - 0x0101010101010101) & ~x & 0x8080808080808080)

	bnz,pn	%ncc, .zerobyte		! x has zero byte, handle end cases

	srlx	%o1, 32, %g1		! get bytes 1,2,3,4

	stw	%g1, [%o2 - 8]		! store bytes 1,2,3,4 (address is pre-incremented)

	ba	.storeword		! no zero byte if magic expression == 0

	stw	%o1, [%o2 - 4]		! store bytes 5,6,7,8

	nop				! padding, do not remove!!!

	nop				! padding, do not remove!!!

	SET_SIZE(strcpy)