/*

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

 */

/*

 * strncpy(s1, s2)

 *

 * Copy string s2 to s1, truncating or null-padding to always copy n bytes

 * return s1.

 *

 * Fast assembler language version of the following C-program for strncpy

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

 *

 *	char *

 *	strncpy(char *s1, const char *s2, size_t n)

 *	{

 *		char *os1 = s1;

 *	

 *		n++;				

 *		while ((--n != 0) &&  ((*s1++ = *s2++) != '\0'))

 *			;

 *		if (n != 0)

 *			while (--n != 0)

 *				*s1++ = '\0';

 *		return (os1);

 *	}

 */

#include <sys/asm_linkage.h>

	! strncpy works similarly to strcpy, except that n bytes of s2

	! are copied to s1. If a null character is reached in s2 yet more

	! bytes remain to be copied, strncpy will copy null bytes into

	! the destination string.

	!

	! This implementation works by first aligning the src ptr and

	! performing small copies until it is aligned.  Then, the string

	! is copied based upon destination alignment.  (byte, half-word,

	! word, etc.)

	ENTRY(strncpy)

	.align 32

	subcc	%g0, %o2, %o4		! n = -n

	bz	.doneshort		! if n == 0, done

	cmp	%o2, 7			! n < 7 ?

	add	%o1, %o2, %o3		! src = src + n

	blu	.shortcpy		! n < 7, use byte-wise copy 

	add	%o0, %o2, %o2		! dst = dst + n

	andcc	%o1, 3, %o5		! src word aligned ?

	bz	.wordaligned		! yup

	save	%sp, -0x40, %sp		! create new register window

	sub	%i5, 4, %i5		! bytes until src aligned

	nop				! align loop on 16-byte boundary

	nop				! align loop on 16-byte boundary

.alignsrc:

	ldub	[%i3 + %i4], %i1	! src[]

	stb	%i1, [%i2 + %i4]	! dst[] = src[]

	inccc	%i4			! src++, dst++, n--

	bz	.done			! n == 0, done

	tst     %i1			! end of src reached (null byte) ?

	bz,a	.bytepad		! yes, at least one byte to pad here

	add 	%i2, %i4, %l0		! need single dest pointer for fill

	inccc	%i5			! src aligned now?

	bnz	.alignsrc		! no, copy another byte

	.empty

.wordaligned:	

	add	%i2, %i4, %l0		! dst

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

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

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

	andcc	%l0, 3, %g1		! destination word aligned ?

	bnz	.dstnotaligned		! nope

	sll	%l1, 7, %i5		! create Alan Mycroft's magic2

.storeword:

	lduw	[%i3 + %i4], %i1	! src dword

	addcc	%i4, 4, %i4		! n += 4, src += 4, dst += 4

	bcs	.lastword		! if counter wraps, last word

	andn	%i5, %i1, %g1		! ~dword & 0x80808080

	sub	%i1, %l1, %l0		! dword - 0x01010101

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

	bz,a	.storeword		! no zero byte if magic expression == 0

	stw	%i1, [%i2 + %i4]	! 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 and then start padding with null bytes

.zerobyte:

	add	%i2, %i4, %l0		! pointer to dest string

	srl	%i1, 24, %g1		! first byte

	stb	%g1, [%l0]		! store it

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null bytes

	srl	%i1, 16, %g1		! second byte

	stb	%g1, [%l0 + 1]		! store it

	and	%g1, 0xff, %g1		! isolate byte

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null bytes

	srl	%i1, 8, %g1		! third byte

	stb	%g1, [%l0 + 2]		! store it

	and	%g1, 0xff, %g1		! isolate byte

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null bytes

	stb	%i1, [%l0 + 3]		! store fourth byte

	addcc	%i4, 8, %g0		! number of pad bytes < 8 ?

	bcs	.bytepad		! yes, do simple byte wise fill

	add	%l0, 4, %l0		! dst += 4

	andcc	%l0, 3, %l1		! dst offset relative to word boundary

	bz	.fillaligned		! dst already word aligned

	! here there is a least one more byte to zero out: otherwise we would 

	! have exited through label .lastword

	sub	%l1, 4, %l1		! bytes to align dst to word boundary

.makealigned:

	stb	%g0, [%l0]		! dst[] = 0

	addcc	%i4, 1, %i4		! n--

	bz	.done			! n == 0, we are done

	addcc	%l1, 1, %l1		! any more byte needed to align

	bnz	.makealigned		! yup, pad another byte

	add	%l0, 1, %l0		! dst++

	nop				! pad to align copy loop below

	! here we know that there at least another 4 bytes to pad, since

	! we don't get here unless there were >= 8 bytes to pad to begin

	! with, and we have padded at most 3 bytes suring dst aligning

.fillaligned:

	add	%i4, 3, %i2		! round up to next word boundary

	and	%i2, -4, %l1		! pointer to next word boundary

	and	%i2, 4, %i2		! word count odd ? 4 : 0

	stw	%g0, [%l0]		! store first word

	addcc	%l1, %i2, %l1		! dword count == 1 ?

	add	%i4, %i2, %i4		! if word count odd, n -= 4

	bz	.bytepad		! if word count == 1, pad bytes left

	add	%l0, %i2, %l0		! bump dst if word count odd

.fillword:	

	addcc	%l1, 8, %l1		! count -= 8

	stw	%g0, [%l0]		! dst[n] = 0

	stw	%g0, [%l0 + 4]		! dst[n+4] = 0

	add	%l0, 8, %l0		! dst += 8

	bcc	.fillword		! fill words until count == 0

	addcc	%i4, 8, %i4		! n -= 8

	bz	.done			! if n == 0, we are done

	.empty

.bytepad:

	and	%i4, 1, %i2		! byte count odd ? 1 : 0

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

	addcc	%i4, %i2, %i4		! byte count == 1 ?

	bz	.done			! yup, we are done

	add	%l0, %i2, %l0		! bump pointer if odd		

.fillbyte:

	addcc	%i4, 2, %i4		! n -= 2

	stb	%g0, [%l0]		! dst[n] = 0

	stb	%g0, [%l0 + 1]		! dst[n+1] = 0

	bnz	.fillbyte		! fill until n == 0

	add	%l0, 2, %l0		! dst += 2

.done:

	ret				! done

	restore	%i0, %g0, %o0		! restore reg window, return dst

	! this is the last word. It may contain null bytes. store bytes 

	! until n == 0. if null byte encountered, continue

.lastword:

	sub	%i4, 4, %i4		! undo counter pre-increment

	add	%i2, 4, %i2		! adjust dst for counter un-bumping

	srl	%i1, 24, %g1		! first byte

	stb	%g1, [%i2 + %i4]	! store it

	inccc	%i4			! n--

	bz	.done			! if n == 0, we're done

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null

	srl	%i1, 16, %g1		! second byte

	stb	%g1, [%i2 + %i4]	! store it

	inccc	%i4			! n--

	bz	.done			! if n == 0, we're done

	and	%g1, 0xff, %g1		! isolate byte

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null

	srl	%i1, 8, %g1		! third byte

	stb	%g1, [%i2 + %i4]	! store it

	inccc	%i4			! n--

	bz	.done			! if n == 0, we're done

	and	%g1, 0xff, %g1		! isolate byte

	sub	%g1, 1, %g1		! byte == 0 ? -1 : byte - 1

	sra	%g1, 31, %g1		! byte == 0 ? -1 : 0

	andn	%i1, %g1, %i1		! if byte == 0, start padding with null

	ba	.done			! here n must be zero, we are done

	stb	%i1, [%i2 + %i4]	! store fourth byte

.dstnotaligned:

	cmp	%g1, 2			! dst half word aligned?

	be	.storehalfword2		! yup, store half word at a time

	.empty

.storebyte:

	lduw	[%i3 + %i4], %i1	! x = src[]

	addcc	%i4, 4, %i4		! src += 4, dst += 4, n -= 4

	bcs	.lastword		! if counter wraps, last word

	andn	%i5, %i1, %g1		! ~x & 0x80808080

	sub	%i1, %l1, %l0		! x - 0x01010101

	andcc	%l0, %g1, %g0		! ((x - 0x01010101) & ~x & 0x80808080)

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

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

	srl	%i1, 24, %g1		! %g1<7:0> = 1st byte; half-word aligned now 

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

	srl	%i1, 8, %g1		! %g1<15:0> = bytes 2, 3

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

	ba	.storebyte		! next word

	stb	%i1, [%l0 + 3]		! store fourth byte

	nop

	nop

.storehalfword:

	lduw	[%i3 + %i4], %i1	! x = src[]

.storehalfword2:

	addcc	%i4, 4, %i4		! src += 4, dst += 4, n -= 4

	bcs	.lastword		! if counter wraps, last word

	andn	%i5, %i1, %g1		! ~x & 0x80808080

	sub	%i1, %l1, %l0		! x - 0x01010101

	andcc	%l0, %g1, %g0		! ((x -0x01010101) & ~x & 0x8080808080)

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

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

	srl	%i1, 16, %g1		! %g1<15:0> = bytes 1, 2

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

	ba	.storehalfword		! next dword

	sth	%i1, [%l0 + 2]		! store bytes 3, 4

.shortcpy:

	ldub	[%o3 + %o4], %o5	! src[]

	stb	%o5, [%o2 + %o4]	! dst[] = src[]

	inccc	%o4			! src++, dst++, n--

	bz	.doneshort		! if n == 0, done

	tst	%o5			! src[] == 0 ?

	bnz,a	.shortcpy		! nope, next byte

	nop				! empty delay slot

.padbyte:

	stb	%g0, [%o2 + %o4]	! dst[] = 0

.padbyte2:

	addcc	%o4, 1, %o4		! dst++, n--

	bnz,a	.padbyte2		! if n != 0, next byte

	stb	%g0, [%o2 + %o4]	! dst[] = 0

	nop				! align label below to 16-byte boundary

.doneshort:

	retl				! return from leaf

	nop				! empty delay slot

	SET_SIZE(strncpy)