/*

 * 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.

 */

/*

 * The strlcpy() function copies at most dstsize-1 characters

 * (dstsize being the size of the string buffer dst) from src

 * to dst, truncating src if necessary. The result is always

 * null-terminated.  The function returns strlen(src). Buffer

 * overflow can be checked as follows:

 *

 *   if (strlcpy(dst, src, dstsize) >= dstsize)

 *           return -1;

 */

#include <sys/asm_linkage.h>

	! strlcpy implementation is similar to that of strcpy, except

	! in this case, the maximum size of the detination must be

	! tracked since it bounds our maximum copy size.  However,

	! we must still continue to check for zero since the routine

	! is expected to null-terminate any string that is within

	! the dest size bound.

	!

	! this method starts by checking for and arranging source alignment.

	! Once this has occurred, we copy based upon destination alignment.

	! This is either by xword, word, halfword, or byte.  As this occurs, we

	! check for a zero-byte.  If one is found, we branch to a method

	! which checks for the exact location of a zero-byte within a 

	! larger xword/word/half-word quantity.

	ENTRY(strlcpy)

	.align 32

	save	%sp, -SA(WINDOWSIZE), %sp

	subcc	%g0, %i2, %g4		! n = -n, n == 0 ?

	bz,pn	%ncc, .getstrlen	! n == 0, must determine strlen

	add	%i1, %i2, %i3		! src = src + n

	andcc	%i1, 7, %i4		! src dword aligned ?

	bz,pn	%ncc, .dwordaligned	! yup

	add	%i0, %i2, %i2		! dst = dst + n

	sub	%i4, 8, %i4		! bytes until src aligned

.alignsrc:

	ldub	[%i3 + %g4], %l1	! src[]

	andcc	%l1, 0xff, %g0		! end of src reached (null byte) ?

	stub	%l1, [%i2 + %g4]	! dst[] = src[]

	bz,a	%ncc, .done		! yes, done

	add 	%i2, %g4, %i2		! need single dest pointer for strlen

	addcc	%g4, 1, %g4		! src++, dst++, n--

	bz,pn	%ncc, .forcenullunalign	! n == 0, force null byte, compute len

	addcc	%i4, 1, %i4		! src aligned now?

	bnz,a	%ncc, .alignsrc		! no, copy another byte

	nop				! pad

.dwordaligned:	

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

	add	%i2, %g4, %l0		! dst

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

	and	%l0, 3, %g1		! dst<1:0> to examine offset

	sllx	%i4, 32, %l1		! spread magic1

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

	or	%i4, %l1, %i4		!   to all 64 bits

	sub	%i2, 8, %i2		! adjust for dest pre-incr in cpy loops

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

	sllx	%i4, 7, %i5		!  Alan Mycroft's magic2

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

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

	cmp	%g1, 2			! dst halfword aligned ?

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

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

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

	nop				! ensure loop is 16-byte aligned

	nop				! ensure loop is 16-byte aligned

.storedword:

	ldx	[%i3 + %g4], %l1	! src dword

	addcc	%g4, 8, %g4		! n += 8, src += 8, dst += 8

	bcs,pn	%ncc, .lastword		! if counter wraps, last word

	andn	%i5, %l1, %g1		! ~dword & 0x8080808080808080

	sub	%l1, %i4, %l0		! dword - 0x0101010101010101

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

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

	stx	%l1, [%i2 + %g4]	! store word to dst (address pre-incremented)

	! n has not expired, but src is at the end. we need to push out the 

	! remaining src bytes. Since strlen(dts) == strlen(src), we can

	! compute the return value as the difference of final dst pointer

	! and the pointer to the start of dst

.zerobyte:

	add	%i2, %g4, %i2		! pointer to dest string

	srlx	%l1, 56, %g1		! first byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 48, %g1		! second byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 40, %g1		! third byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 32, %g1		! fourth byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 24, %g1		! fifth byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 16, %g1		! sixth byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	add	%i2, 1, %i2		! dst++

	srlx	%l1, 8, %g1		! seventh byte

	andcc	%g1, 0xff, %g0		! end of string ?

	bz,pn	%ncc, .done		! yup, copy done, return length

	stb	%g1, [%i2]		! store it

	stb	%l1, [%i2 + 1]		! store eigth byte

	add	%i2, 1, %i2		! dst++

.done:

	sub	%i2, %i0, %i0		! len = dst - orig dst

	ret				! subroutine done

	restore	%i0, %g0, %o0		! restore register window, return len

	! n expired, so this is the last word. It may contain null bytes.

	! Store bytes until n == 0. If a null byte is encountered during 

	! processing of this last src word, we are done. Otherwise continue

	! to scan src until we hit the end, and compute strlen from the

	! difference between the pointer past the last byte of src and the

	! original pointer to the start of src

.lastword:

	add	%i2, %g4, %i2		! we want a single dst pointer here

	sub	%g4, 8, %g4		! undo counter pre-increment

	add	%i3, %g4, %i3		! we want a single src pointer here

	srlx	%l1, 56, %g1		! first byte

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute len

	srlx	%l1, 48, %g1		! second byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute len

	srlx	%l1, 40, %g1		! third byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute strlen

	srlx	%l1, 32, %g1		! fourth byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute strlen

	srlx	%l1, 24, %g1		! fifth byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute strlen

	srlx	%l1, 16, %g1		! sixth byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute strlen

	srlx	%l1, 8, %g1		! seventh byte

	add	%i2, 1, %i2		! dst++

	andcc	%g1, 0xff, %g0		! end of src reached ?

	bz,pn	%ncc, .done		! yup

	stb	%g1, [%i2]		! store it

	inccc	%g4			! n--

	bz	.forcenull		! if n == 0, force null byte, compute strlen

	andcc	%l1, 0xff, %g0		! end of src reached ?

	add	%i2, 1, %i2		! dst++

	bz,pn	%ncc, .done		! yup

	stb	%l1, [%i2]		! store eigth byte

	! we need to force a null byte in the last position of dst

	! %i2 points to the location

.forcenull:

	stb	%g0, [%i2]		! force string terminating null byte

	! here: %i1 points to src start

	!	%i3 points is current src ptr (8-byte aligned)

.searchword:

	ldx	[%i3], %l1		! src dword

.searchword2:

	andn	%i5, %l1, %g1		! ~dword & 0x8080808080808080

	sub	%l1, %i4, %l0		! dword - 0x0101010101010101

	andcc	%l0, %g1, %g0		! ((dword - 0x0101010101010101) & ~dword & 0x80808080

	bz,a,pt	%ncc, .searchword	! no null byte if expression is 0

	add	%i3, 8, %i3		! src += 8

	mov	0xff, %i5		! create byte mask for null byte scanning

	sllx	%i5, 56, %i5		! mask for 1st byte = 0xff0000000000000000

.searchbyte:	

	andcc	%l1, %i5, %g0		! current byte zero?

	srlx	%i5, 8, %i5		! byte mask for next byte

	bnz,a	%ncc, .searchbyte	! current byte != zero, continue search

	add	%i3, 1, %i3		! src++

.endfound:

	sub	%i3, %i1, %i0		! len = src - orig src

	ret				! done

	restore	%i0, %g0, %o0		! restore register window, return len

	nop				! align loop on 16-byte

.storebyte1421:

	ldx	[%i3 + %g4], %l1	! x = src[]

	addcc	%g4, 8, %g4		! src += 8, dst += 8

	bcs,pn	%ncc, .lastword		! if counter wraps, last word

	andn	%i5, %l1, %g1		! ~x & 0x8080808080808080

	sub	%l1, %i4, %l0		! x - 0x0101010101010101

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

	bnz,pn	%ncc, .zerobyte		! end of src found, may need to pad

	add	%i2, %g4, %l0		! dst (in pointer form)

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

	stb	%g1, [%l0]		! store first byte

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

	stw	%g1, [%l0 + 1]		! store bytes 2, 3, 4, 5

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

	sth	%g1, [%l0 + 5]		! store bytes 6, 7

	ba	.storebyte1421		! next dword

	stb	%l1, [%l0 + 7]		! store eigth byte

.storebyte1241:

	ldx	[%i3 + %g4], %l1	! x = src[]

	addcc	%g4, 8, %g4		! src += 8, dst += 8

	bcs,pn	%ncc, .lastword		! if counter wraps, last word

	andn	%i5, %l1, %g1		! ~x & 0x8080808080808080

	sub	%l1, %i4, %l0		! x - 0x0101010101010101

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

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

	add	%i2, %g4, %l0		! dst (in pointer form)

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

	stb	%g1, [%l0]		! store first byte

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

	sth	%g1, [%l0 + 1]		! store bytes 2, 3

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

	stw	%g1, [%l0 + 3]		! store bytes 4, 5, 6, 7

	ba	.storebyte1241		! next dword

	stb	%l1, [%l0 + 7]		! store eigth byte

.storehalfword:

	ldx	[%i3 + %g4], %l1	! x = src[]

	addcc	%g4, 8, %g4		! src += 8, dst += 8

	bcs,pn	%ncc, .lastword		! if counter wraps, last word

	andn	%i5, %l1, %g1		! ~x & 0x8080808080808080

	sub	%l1, %i4, %l0		! x - 0x0101010101010101

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

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

	add	%i2, %g4, %l0		! dst (in pointer form)

	srlx	%l1, 48, %g1		! %g1<15:0> = bytes 1, 2; word aligned now

	sth	%g1, [%l0]		! store bytes 1, 2

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

	stw	%g1, [%l0 + 2]		! store bytes 3, 4, 5, 6

	ba	.storehalfword		! next dword

	sth	%l1, [%l0 + 6]		! store bytes 7, 8

	nop				! align next loop to 16-byte boundary

	nop				! align next loop to 16-byte boundary

.storeword2:

	ldx	[%i3 + %g4], %l1	! x = src[]

	addcc	%g4, 8, %g4		! src += 8, dst += 8

	bcs,pn	%ncc, .lastword		! if counter wraps, last word

	andn	%i5, %l1, %g1		! ~x & 0x8080808080808080

	sub	%l1, %i4, %l0		! x - 0x0101010101010101

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

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

	add	%i2, %g4, %l0		! dst (in pointer form)

	srlx	%l1, 32, %g1		! %g1<31:0> = bytes 1, 2, 3, 4

	stw	%g1, [%l0]		! store bytes 1, 2, 3, 4

	ba	.storeword2		! next dword

	stw	%l1, [%l0 + 4]		! store bytes 5, 6, 7, 8

	! n expired, i.e. end of destination buffer reached. Force null 

	! null termination of dst, then scan src until end foudn for

	! determination of strlen(src)

	!

	! here: %i3 points to current src byte

	!       %i2 points one byte past end of dst

	! magic constants not loaded

.forcenullunalign:

	add	%i2, %g4, %i2		! we need a single dst ptr

	stb	%g0, [%i2 - 1]		! force string terminating null byte

.getstrlen:

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

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

	sllx	%i4, 32, %i2		! spread magic1

	or	%i4, %i2, %i4		!   to all 64 bits

	sllx	%i4, 7, %i5		!  Alan Mycroft's magic2

	nop				! align loop to 16-byte boundary

.getstrlenloop:

	andcc	%i3, 7, %g0		! src dword aligned?

	bz,a,pn	%ncc, .searchword2	! yup, now search a dword at a time

	ldx	[%i3], %l1		! src dword

	ldub	[%i3], %l1		! load src byte

	andcc	%l1, 0xff, %g0		! end of src reached?

	bnz,a	%ncc, .getstrlenloop	! yup, return length

	add	%i3, 1, %i3		! src++

	sub	%i3, %i1, %i0		! len = src - orig src

	ret				! done

	restore	%i0, %g0, %o0		! restore register window, return len

	nop				! pad tp 16-byte boundary

	nop				! pad tp 16-byte boundary

	SET_SIZE(strlcpy)