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