1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27	.file	"strcmp.s"
28
29/* strcmp(s1, s2)
30 *
31 * Compare strings:  s1>s2: >0  s1==s2: 0  s1<s2: <0
32 *
33 * Fast assembler language version of the following C-program for strcmp
34 * which represents the `standard' for the C-library.
35 *
36 *	int
37 *	strcmp(s1, s2)
38 *	register const char *s1;
39 *	register const char *s2;
40 *	{
41 *
42 *		if(s1 == s2)
43 *			return(0);
44 *		while(*s1 == *s2++)
45 *			if(*s1++ == '\0')
46 *				return(0);
47 *		return(*s1 - s2[-1]);
48 *	}
49 */
50
51#include <sys/asm_linkage.h>
52
53	! This strcmp implementation first determines whether s1 is aligned.
54	! If it is not, it attempts to align it and then checks the
55	! alignment of the destination string.  If it is possible to
56	! align s2, this also happens and then the compare begins.  Otherwise,
57	! a different compare for non-aligned strings is used.
58	! In this case, we have multiple routines depending upon the
59	! degree to which a string is mis-aligned.
60
61	ENTRY(strcmp)
62
63	.align 32
64
65	subcc	%o0, %o1, %o2		! s1 == s2 ?
66	bz	.stringsequal1		! yup, same string, done
67	sethi	%hi(0x01010101), %o5	! start loading Mycroft's magic2
68	andcc	%o0, 3, %o3		! s1 word-aligned ?
69	or	%o5, %lo(0x01010101),%o5! finish loading Mycroft's magic2
70	bz	.s1aligned		! yup
71	sll	%o5, 7, %o4		! load Mycroft's magic1
72	sub	%o3, 4, %o3		! number of bytes till aligned
73
74.aligns1:
75	ldub	[%o1 + %o2], %o0	! s1[]
76	ldub	[%o1], %g1		! s2[]
77	subcc	%o0, %g1, %o0		! s1[] != s2[] ?
78	bne	.done			! yup, done
79	addcc	%o0, %g1, %g0		! s1[] == 0 ?
80	bz	.done			! yup, done
81	inccc	%o3			! s1 aligned yet?
82	bnz	.aligns1		! nope, compare another pair of bytes
83	inc	%o1			! s1++, s2++
84
85.s1aligned:
86	andcc	%o1, 3, %o3		! s2 word aligned ?
87	bz	.word4			! yup
88	cmp	%o3, 2			! s2 half-word aligned ?
89	be	.word2			! yup
90	cmp	%o3, 3			! s2 offset to dword == 3 ?
91	be,a	.word3			! yup
92	ldub	[%o1], %o0		! new lower word in s2
93
94.word1:
95	lduw	[%o1 - 1], %o0		! new lower word in s2
96	sethi	%hi(0xff000000), %o3	! mask for forcing byte 1 non-zero
97	sll	%o0, 8, %g1		! partial unaligned word from s2
98	or	%o0, %o3, %o0		! force byte 1 non-zero
99
100.cmp1:
101	andn	%o4, %o0, %o3		! ~word & 0x80808080
102	sub	%o0, %o5, %o0		! word - 0x01010101
103	andcc	%o0, %o3, %g0		! (word - 0x01010101) & ~word & 0x80808080
104	bz,a	.doload1		! no null byte in previous word from s2
105	lduw	[%o1 + 3], %o0		! load next aligned word from s2
106.doload1:
107	srl	%o0, 24, %o3		! byte 1 of new aligned word from s2
108	or	%g1, %o3, %g1		! merge to get unaligned word from s2
109	lduw	[%o1 + %o2], %o3	! word from s1
110	cmp	%o3, %g1		! *s1 != *s2 ?
111	bne	.wordsdiffer		! yup, find the byte that is different
112	add	%o1, 4, %o1		! s1+=4, s2+=4
113	andn	%o4, %o3, %g1		! ~word & 0x80808080
114	sub	%o3, %o5, %o3		! word - 0x01010101
115	andcc	%o3, %g1, %g0		! (word - 0x01010101) & ~word & 0x80808080
116	bz	.cmp1			! no null-byte in s1 yet
117	sll	%o0, 8, %g1		! partial unaligned word from s2
118
119	! words are equal but the end of s1 has been reached
120	! this means the strings must be equal
121.stringsequal1:
122	retl				! return from leaf function
123	mov	%g0, %o0		! return 0, i.e. strings are equal
124	nop				! pad for optimal alignment of .cmp2
125	nop				! pad for optimal alignment of .cmp2
126
127.word2:
128	lduh	[%o1], %o0		! new lower word in s2
129	sethi	%hi(0xffff0000), %o3	! mask for forcing bytes 1,2 non-zero
130	sll	%o0, 16, %g1		! partial unaligned word from s2
131	or	%o0, %o3, %o0		! force bytes 1,2 non-zero
132
133.cmp2:
134	andn	%o4, %o0, %o3		! ~word & 0x80808080
135	sub	%o0, %o5, %o0		! word - 0x01010101
136	andcc	%o0, %o3, %g0		! (word - 0x01010101) & ~word & 0x80808080
137	bz,a	.doload2		! no null byte in previous word from s2
138	lduw	[%o1 + 2], %o0		! load next aligned word from s2
139.doload2:
140	srl	%o0, 16, %o3		! bytes 1,2 of new aligned word from s2
141	or	%g1, %o3, %g1		! merge to get unaligned word from s2
142	lduw	[%o1 + %o2], %o3	! word from s1
143	cmp	%o3, %g1		! *s1 != *s2 ?
144	bne	.wordsdiffer		! yup, find the byte that is different
145	add	%o1, 4, %o1		! s1+=4, s2+=4
146	andn	%o4, %o3, %g1		! ~word & 0x80808080
147	sub	%o3, %o5, %o3		! word - 0x01010101
148	andcc	%o3, %g1, %g0		! (word - 0x01010101) & ~word & 0x80808080
149	bz	.cmp2			! no null-byte in s1 yet
150	sll	%o0, 16, %g1		! partial unaligned word from s2
151
152	! words are equal but the end of s1 has been reached
153	! this means the strings must be equal
154.stringsequal2:
155	retl				! return from leaf function
156	mov	%g0, %o0		! return 0, i.e. strings are equal
157
158.word3:
159	sll	%o0, 24, %g1		! partial unaligned word from s2
160	nop				! pad for optimal alignment of .cmp3
161.cmp3:
162	andcc	%o0, 0xff, %g0		! did previous word contain null-byte ?
163	bnz,a	.doload3		! nope, load next word from s2
164	lduw	[%o1 + 1], %o0		! load next aligned word from s2
165.doload3:
166	srl	%o0, 8, %o3		! bytes 1,2,3 from new aligned s2 word
167	or	%g1, %o3, %g1		! merge to get unaligned word from s2
168	lduw	[%o1 + %o2], %o3	! word from s1
169	cmp	%o3, %g1		! *s1 != *s2 ?
170	bne	.wordsdiffer		! yup, find the byte that is different
171	add	%o1, 4, %o1		! s1+=4, s2+=4
172	andn	%o4, %o3, %g1		! ~word & 0x80808080
173	sub	%o3, %o5, %o3		! word - 0x01010101
174	andcc	%o3, %g1, %g0		! (word - 0x01010101) & ~word & 0x80808080
175	bz	.cmp3			! no null-byte in s1 yet
176	sll	%o0, 24, %g1		! partial unaligned word from s2
177
178	! words are equal but the end of s1 has been reached
179	! this means the strings must be equal
180.stringsequal3:
181	retl				! return from leaf function
182	mov	%g0, %o0		! return 0, i.e. strings are equal
183
184.word4:
185	lduw	[%o1 + %o2], %o3	! load word from s1
186	nop				! pad for optimal alignment of .cmp4
187	nop				! pad for optimal alignment of .cmp4
188	nop				! pad for optimal alignment of .cmp4
189
190.cmp4:
191	lduw	[%o1], %g1		! load word from s2
192	cmp	%o3, %g1		! *scr1 == *src2 ?
193	bne	.wordsdiffer		! nope, find mismatching character
194	add	%o1, 4, %o1		! src1 += 4, src2 += 4
195	andn	%o4, %o3, %o0		! ~word & 0x80808080
196	sub	%o3, %o5, %o3		! word - 0x01010101
197	andcc	%o3, %o0, %g0		! (word - 0x01010101) & ~word & 0x80808080
198	bz,a	.cmp4			! no null-byte in s1 yet
199	lduw	[%o1 + %o2], %o3	! load word from s1
200
201	! words are equal but the end of s1 has been reached
202	! this means the strings must be equal
203.stringsequal4:
204	retl				! return from leaf function
205	mov	%g0, %o0		! return 0, i.e. strings are equal
206
207.wordsdiffer:
208	srl	%g1, 24, %o2		! first byte of mismatching word in s2
209	srl	%o3, 24, %o1		! first byte of mismatching word in s1
210	subcc	%o1, %o2, %o0		! *s1-*s2
211	bnz	.done			! bytes differ, return difference
212	srl	%g1, 16, %o2		! second byte of mismatching word in s2
213	andcc	%o1, 0xff, %o0		! *s1 == 0 ?
214	bz	.done			! yup
215
216	! we know byte 1 is equal, so can compare bytes 1,2 as a group
217
218	srl	%o3, 16, %o1		! second byte of mismatching word in s1
219	subcc	%o1, %o2, %o0		! *s1-*s2
220	bnz	.done			! bytes differ, return difference
221	srl	%g1, 8, %o2		! third byte of mismatching word in s2
222	andcc	%o1, 0xff, %o0		! *s1 == 0 ?
223	bz	.done			! yup
224
225	! we know bytes 1, 2 are equal, so can compare bytes 1,2,3 as a group
226
227	srl	%o3, 8, %o1		! third byte of mismatching word in s1
228	subcc	%o1, %o2, %o0		! *s1-*s2
229	bnz	.done			! bytes differ, return difference
230	andcc	%o1, 0xff, %g0		! *s1 == 0 ?
231	bz	.stringsequal1		! yup
232
233	! we know bytes 1,2,3 are equal, so can compare bytes 1,2,3,4 as group
234
235	subcc	%o3, %g1, %o0		! *s1-*s2
236	bz,a	.done			! bytes differ, return difference
237	andcc	%o3, 0xff, %o0		! *s1 == 0 ?
238
239.done:
240	retl				! return from leaf routine
241	nop				! padding
242
243
244	SET_SIZE(strcmp)
245