/*
* 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 "strcmp.s"
/* strcmp(s1, s2)
*
* Compare strings: s1>s2: >0 s1==s2: 0 s1<s2: <0
*
* Fast assembler language version of the following C-program for strcmp
* which represents the `standard' for the C-library.
*
* int
* strcmp(s1, s2)
* register const char *s1;
* register const char *s2;
* {
*
* if(s1 == s2)
* return(0);
* while(*s1 == *s2++)
* if(*s1++ == '\0')
* return(0);
* return(*s1 - s2[-1]);
* }
*/
#include <sys/asm_linkage.h>
! This strcmp implementation first determines whether s1 is aligned.
! If it is not, it attempts to align it and then checks the
! alignment of the destination string. If it is possible to
! align s2, this also happens and then the compare begins. Otherwise,
! a different compare for non-aligned strings is used.
! In this case, we have multiple routines depending upon the
! degree to which a string is mis-aligned.
ENTRY(strcmp)
.align 32
subcc %o0, %o1, %o2 ! s1 == s2 ?
bz .stringsequal1 ! yup, same string, done
sethi %hi(0x01010101), %o5 ! start loading Mycroft's magic2
andcc %o0, 3, %o3 ! s1 word-aligned ?
or %o5, %lo(0x01010101),%o5! finish loading Mycroft's magic2
bz .s1aligned ! yup
sll %o5, 7, %o4 ! load Mycroft's magic1
sub %o3, 4, %o3 ! number of bytes till aligned
.aligns1:
ldub [%o1 + %o2], %o0 ! s1[]
ldub [%o1], %g1 ! s2[]
subcc %o0, %g1, %o0 ! s1[] != s2[] ?
bne .done ! yup, done
addcc %o0, %g1, %g0 ! s1[] == 0 ?
bz .done ! yup, done
inccc %o3 ! s1 aligned yet?
bnz .aligns1 ! nope, compare another pair of bytes
inc %o1 ! s1++, s2++
.s1aligned:
andcc %o1, 3, %o3 ! s2 word aligned ?
bz .word4 ! yup
cmp %o3, 2 ! s2 half-word aligned ?
be .word2 ! yup
cmp %o3, 3 ! s2 offset to dword == 3 ?
be,a .word3 ! yup
ldub [%o1], %o0 ! new lower word in s2
.word1:
lduw [%o1 - 1], %o0 ! new lower word in s2
sethi %hi(0xff000000), %o3 ! mask for forcing byte 1 non-zero
sll %o0, 8, %g1 ! partial unaligned word from s2
or %o0, %o3, %o0 ! force byte 1 non-zero
.cmp1:
andn %o4, %o0, %o3 ! ~word & 0x80808080
sub %o0, %o5, %o0 ! word - 0x01010101
andcc %o0, %o3, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz,a .doload1 ! no null byte in previous word from s2
lduw [%o1 + 3], %o0 ! load next aligned word from s2
.doload1:
srl %o0, 24, %o3 ! byte 1 of new aligned word from s2
or %g1, %o3, %g1 ! merge to get unaligned word from s2
lduw [%o1 + %o2], %o3 ! word from s1
cmp %o3, %g1 ! *s1 != *s2 ?
bne .wordsdiffer ! yup, find the byte that is different
add %o1, 4, %o1 ! s1+=4, s2+=4
andn %o4, %o3, %g1 ! ~word & 0x80808080
sub %o3, %o5, %o3 ! word - 0x01010101
andcc %o3, %g1, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz .cmp1 ! no null-byte in s1 yet
sll %o0, 8, %g1 ! partial unaligned word from s2
! words are equal but the end of s1 has been reached
! this means the strings must be equal
.stringsequal1:
retl ! return from leaf function
mov %g0, %o0 ! return 0, i.e. strings are equal
nop ! pad for optimal alignment of .cmp2
nop ! pad for optimal alignment of .cmp2
.word2:
lduh [%o1], %o0 ! new lower word in s2
sethi %hi(0xffff0000), %o3 ! mask for forcing bytes 1,2 non-zero
sll %o0, 16, %g1 ! partial unaligned word from s2
or %o0, %o3, %o0 ! force bytes 1,2 non-zero
.cmp2:
andn %o4, %o0, %o3 ! ~word & 0x80808080
sub %o0, %o5, %o0 ! word - 0x01010101
andcc %o0, %o3, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz,a .doload2 ! no null byte in previous word from s2
lduw [%o1 + 2], %o0 ! load next aligned word from s2
.doload2:
srl %o0, 16, %o3 ! bytes 1,2 of new aligned word from s2
or %g1, %o3, %g1 ! merge to get unaligned word from s2
lduw [%o1 + %o2], %o3 ! word from s1
cmp %o3, %g1 ! *s1 != *s2 ?
bne .wordsdiffer ! yup, find the byte that is different
add %o1, 4, %o1 ! s1+=4, s2+=4
andn %o4, %o3, %g1 ! ~word & 0x80808080
sub %o3, %o5, %o3 ! word - 0x01010101
andcc %o3, %g1, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz .cmp2 ! no null-byte in s1 yet
sll %o0, 16, %g1 ! partial unaligned word from s2
! words are equal but the end of s1 has been reached
! this means the strings must be equal
.stringsequal2:
retl ! return from leaf function
mov %g0, %o0 ! return 0, i.e. strings are equal
.word3:
sll %o0, 24, %g1 ! partial unaligned word from s2
nop ! pad for optimal alignment of .cmp3
.cmp3:
andcc %o0, 0xff, %g0 ! did previous word contain null-byte ?
bnz,a .doload3 ! nope, load next word from s2
lduw [%o1 + 1], %o0 ! load next aligned word from s2
.doload3:
srl %o0, 8, %o3 ! bytes 1,2,3 from new aligned s2 word
or %g1, %o3, %g1 ! merge to get unaligned word from s2
lduw [%o1 + %o2], %o3 ! word from s1
cmp %o3, %g1 ! *s1 != *s2 ?
bne .wordsdiffer ! yup, find the byte that is different
add %o1, 4, %o1 ! s1+=4, s2+=4
andn %o4, %o3, %g1 ! ~word & 0x80808080
sub %o3, %o5, %o3 ! word - 0x01010101
andcc %o3, %g1, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz .cmp3 ! no null-byte in s1 yet
sll %o0, 24, %g1 ! partial unaligned word from s2
! words are equal but the end of s1 has been reached
! this means the strings must be equal
.stringsequal3:
retl ! return from leaf function
mov %g0, %o0 ! return 0, i.e. strings are equal
.word4:
lduw [%o1 + %o2], %o3 ! load word from s1
nop ! pad for optimal alignment of .cmp4
nop ! pad for optimal alignment of .cmp4
nop ! pad for optimal alignment of .cmp4
.cmp4:
lduw [%o1], %g1 ! load word from s2
cmp %o3, %g1 ! *scr1 == *src2 ?
bne .wordsdiffer ! nope, find mismatching character
add %o1, 4, %o1 ! src1 += 4, src2 += 4
andn %o4, %o3, %o0 ! ~word & 0x80808080
sub %o3, %o5, %o3 ! word - 0x01010101
andcc %o3, %o0, %g0 ! (word - 0x01010101) & ~word & 0x80808080
bz,a .cmp4 ! no null-byte in s1 yet
lduw [%o1 + %o2], %o3 ! load word from s1
! words are equal but the end of s1 has been reached
! this means the strings must be equal
.stringsequal4:
retl ! return from leaf function
mov %g0, %o0 ! return 0, i.e. strings are equal
.wordsdiffer:
srl %g1, 24, %o2 ! first byte of mismatching word in s2
srl %o3, 24, %o1 ! first byte of mismatching word in s1
subcc %o1, %o2, %o0 ! *s1-*s2
bnz .done ! bytes differ, return difference
srl %g1, 16, %o2 ! second byte of mismatching word in s2
andcc %o1, 0xff, %o0 ! *s1 == 0 ?
bz .done ! yup
! we know byte 1 is equal, so can compare bytes 1,2 as a group
srl %o3, 16, %o1 ! second byte of mismatching word in s1
subcc %o1, %o2, %o0 ! *s1-*s2
bnz .done ! bytes differ, return difference
srl %g1, 8, %o2 ! third byte of mismatching word in s2
andcc %o1, 0xff, %o0 ! *s1 == 0 ?
bz .done ! yup
! we know bytes 1, 2 are equal, so can compare bytes 1,2,3 as a group
srl %o3, 8, %o1 ! third byte of mismatching word in s1
subcc %o1, %o2, %o0 ! *s1-*s2
bnz .done ! bytes differ, return difference
andcc %o1, 0xff, %g0 ! *s1 == 0 ?
bz .stringsequal1 ! yup
! we know bytes 1,2,3 are equal, so can compare bytes 1,2,3,4 as group
subcc %o3, %g1, %o0 ! *s1-*s2
bz,a .done ! bytes differ, return difference
andcc %o3, 0xff, %o0 ! *s1 == 0 ?
.done:
retl ! return from leaf routine
nop ! padding
SET_SIZE(strcmp)