xref: /titanic_41/usr/src/lib/libc/sparc/gen/strcpy.s (revision 9a70fc3be3b1e966bf78825cdb8d509963a6f0a1)

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

	.file	"strcpy.s"

/*
 * 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 is a 32-bit implementation of strcpy.  It works by
	! first checking the alignment of its source pointer. And,
	! if it is not aligned, attempts to copy bytes until it is.
	! once this has occurred, the copy takes place, while checking
	! for zero bytes, based upon destination alignment.
	! Methods exist to handle per-byte, half-word, and word sized
	! copies.

	ENTRY(strcpy)

	.align 32

	sub	%o1, %o0, %o3		! src - dst
	andcc	%o1, 3, %o4		! src word aligned ?
	bz	.srcaligned		! yup
	mov	%o0, %o2		! save dst

	cmp	%o4, 2			! src halfword aligned
	be	.s2aligned		! yup
	ldub	[%o2 + %o3], %o1	! src[0]
	tst	%o1			! byte zero?
	stb	%o1, [%o2]		! store first byte
	bz	.done			! yup, done
	cmp	%o4, 3			! only one byte needed to align?
	bz	.srcaligned		! yup
	inc	%o2			! src++, dst++

.s2aligned:
	lduh	[%o2 + %o3], %o1	! src[]
	srl	%o1, 8, %o4		! %o4<7:0> = first byte
	tst	%o4			! first byte zero ?
	bz	.done			! yup, done
	stb	%o4, [%o2]		! store first byte
	andcc	%o1, 0xff, %g0		! second byte zero ?
	bz	.done			! yup, done
	stb	%o1, [%o2 + 1]		! store second byte
	add	%o2, 2, %o2		! src += 2, dst += 2

.srcaligned:
	sethi	%hi(0x01010101), %o4	! Alan Mycroft's magic1
	sethi	%hi(0x80808080), %o5	! Alan Mycroft's magic2
	or	%o4, %lo(0x01010101), %o4
	andcc	%o2, 3, %o1		! destination word aligned?
	bnz	.dstnotaligned		! nope
	or	%o5, %lo(0x80808080), %o5

.copyword:
	lduw	[%o2 + %o3], %o1	! src word
	add	%o2, 4, %o2		! src += 4, dst += 4
	andn	%o5, %o1, %g1		! ~word & 0x80808080
	sub	%o1, %o4, %o1		! word - 0x01010101
	andcc	%o1, %g1, %g0		! ((word - 0x01010101) & ~word & 0x80808080)
	add	%o1, %o4, %o1		! restore word
	bz,a	.copyword		! no zero byte if magic expression == 0
	st	%o1, [%o2 - 4]		! store word to dst (address pre-incremented)

.zerobyte:
	set	0xff000000, %o4		! mask for 1st byte
	srl	%o1, 24, %o3		! %o3<7:0> = first byte
	andcc	%o1, %o4, %g0		! first byte zero?
	bz	.done			! yup, done
	stb	%o3, [%o2 - 4]		! store first byte
	set	0x00ff0000, %o5		! mask for 2nd byte
	srl	%o1, 16, %o3		! %o3<7:0> = second byte
	andcc	%o1, %o5, %g0		! second byte zero?
	bz	.done			! yup, done
	stb	%o3, [%o2 - 3]		! store second byte
	srl	%o4, 16, %o4		! 0x0000ff00 = mask for 3rd byte
	andcc	%o1, %o4, %g0		! third byte zero?
	srl	%o1, 8, %o3		! %o3<7:0> = third byte
	bz	.done			! yup, done
	stb	%o3, [%o2 - 2]		! store third byte
	stb	%o1, [%o2 - 1]		! store fourth byte

.done:
	retl				! done with leaf function
	.empty

.dstnotaligned:
	cmp	%o1, 2			! dst half word aligned?
	be,a	.storehalfword2		! yup, store half word at a time
	lduw	[%o2 + %o3], %o1	! src word

.storebyte:
	lduw	[%o2 + %o3], %o1	! src word
	add	%o2, 4, %o2		! src += 4, dst += 4
	sub	%o1, %o4, %g1		! x - 0x01010101
	andn	%g1, %o1, %g1		! (x - 0x01010101) & ~x
	andcc	%g1, %o5, %g0		! ((x - 0x01010101) & ~x & 0x80808080)
	bnz	.zerobyte		! word has zero byte, handle end cases
	srl	%o1, 24, %g1		! %g1<7:0> = first byte
	stb	%g1, [%o2 - 4]		! store first byte; half-word aligned now
	srl	%o1, 8, %g1		! %g1<15:0> = byte 2, 3
	sth	%g1, [%o2 - 3]		! store bytes 2, 3
	ba	.storebyte		! next word
	stb	%o1, [%o2 - 1]		! store fourth byte

.storehalfword:
	lduw	[%o2 + %o3], %o1	! src word
.storehalfword2:
	add	%o2, 4, %o2		! src += 4, dst += 4
	sub	%o1, %o4, %g1		! x - 0x01010101
	andn	%g1, %o1, %g1		! (x - 0x01010101) & ~x
	andcc	%g1, %o5, %g0		! ((x - 0x01010101) & ~x & 0x80808080)
	bnz	.zerobyte		! word has zero byte, handle end cases
	srl	%o1, 16, %g1		! get first and second byte
	sth	%g1, [%o2 - 4]		! store first and second byte
	ba	.storehalfword		! next word
	sth	%o1, [%o2 - 2]		! store third and fourth byte

	! DO NOT remove these NOPs. It will slow down the halfword loop by 15%

	nop				! padding
	nop				! padding

	SET_SIZE(strcpy)