sysdeps/i386/strchr.S

   1 /* strchr (str, ch) -- Return pointer to first occurrence of CH in STR.
   2    For Intel 80x86, x>=3.
   3    Copyright (C) 1994-2019 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5    Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>
   6    Some optimisations by Alan Modra <Alan@SPRI.Levels.UniSA.Edu.Au>
   7
   8    The GNU C Library is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU Lesser General Public
  10    License as published by the Free Software Foundation; either
  11    version 2.1 of the License, or (at your option) any later version.
  12
  13    The GNU C Library is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    Lesser General Public License for more details.
  17
  18    You should have received a copy of the GNU Lesser General Public
  19    License along with the GNU C Library; if not, see
  20    <http://www.gnu.org/licenses/>.  */
  21
  22 #include <sysdep.h>
  23 #include "asm-syntax.h"
  24
  25 #define PARMS   4+4             /* space for 1 saved reg */
  26 #define RTN     PARMS
  27 #define STR     RTN
  28 #define CHR     STR+4
  29
  30         .text
  31 ENTRY (strchr)
  32
  33         pushl %edi              /* Save callee-safe registers used here.  */
  34         cfi_adjust_cfa_offset (4)
  35         cfi_rel_offset (edi, 0)
  36         movl STR(%esp), %eax
  37         movl CHR(%esp), %edx
  38
  39         /* At the moment %edx contains C.  What we need for the
  40            algorithm is C in all bytes of the dword.  Avoid
  41            operations on 16 bit words because these require an
  42            prefix byte (and one more cycle).  */
  43         movb %dl, %dh           /* now it is 0|0|c|c */
  44         movl %edx, %ecx
  45         shll $16, %edx          /* now it is c|c|0|0 */
  46         movw %cx, %dx           /* and finally c|c|c|c */
  47
  48         /* Before we start with the main loop we process single bytes
  49            until the source pointer is aligned.  This has two reasons:
  50            1. aligned 32-bit memory access is faster
  51            and (more important)
  52            2. we process in the main loop 32 bit in one step although
  53               we don't know the end of the string.  But accessing at
  54               4-byte alignment guarantees that we never access illegal
  55               memory if this would not also be done by the trivial
  56               implementation (this is because all processor inherent
  57               boundaries are multiples of 4.  */
  58
  59         testb $3, %al           /* correctly aligned ? */
  60         jz L(11)                /* yes => begin loop */
  61         movb (%eax), %cl        /* load byte in question (we need it twice) */
  62         cmpb %cl, %dl           /* compare byte */
  63         je L(6)                 /* target found => return */
  64         testb %cl, %cl          /* is NUL? */
  65         jz L(2)                 /* yes => return NULL */
  66         incl %eax               /* increment pointer */
  67
  68         testb $3, %al           /* correctly aligned ? */
  69         jz L(11)                /* yes => begin loop */
  70         movb (%eax), %cl        /* load byte in question (we need it twice) */
  71         cmpb %cl, %dl           /* compare byte */
  72         je L(6)                 /* target found => return */
  73         testb %cl, %cl          /* is NUL? */
  74         jz L(2)                 /* yes => return NULL */
  75         incl %eax               /* increment pointer */
  76
  77         testb $3, %al           /* correctly aligned ? */
  78         jz L(11)                /* yes => begin loop */
  79         movb (%eax), %cl        /* load byte in question (we need it twice) */
  80         cmpb %cl, %dl           /* compare byte */
  81         je L(6)                 /* target found => return */
  82         testb %cl, %cl          /* is NUL? */
  83         jz L(2)                 /* yes => return NULL */
  84         incl %eax               /* increment pointer */
  85
  86         /* No we have reached alignment.  */
  87         jmp L(11)               /* begin loop */
  88
  89       /* We exit the loop if adding MAGIC_BITS to LONGWORD fails to
  90          change any of the hole bits of LONGWORD.
  91
  92          1) Is this safe?  Will it catch all the zero bytes?
  93          Suppose there is a byte with all zeros.  Any carry bits
  94          propagating from its left will fall into the hole at its
  95          least significant bit and stop.  Since there will be no
  96          carry from its most significant bit, the LSB of the
  97          byte to the left will be unchanged, and the zero will be
  98          detected.
  99
 100          2) Is this worthwhile?  Will it ignore everything except
 101          zero bytes?  Suppose every byte of LONGWORD has a bit set
 102          somewhere.  There will be a carry into bit 8.  If bit 8
 103          is set, this will carry into bit 16.  If bit 8 is clear,
 104          one of bits 9-15 must be set, so there will be a carry
 105          into bit 16.  Similarly, there will be a carry into bit
 106          24.  If one of bits 24-31 is set, there will be a carry
 107          into bit 32 (=carry flag), so all of the hole bits will
 108          be changed.
 109
 110          3) But wait!  Aren't we looking for C, not zero?
 111          Good point.  So what we do is XOR LONGWORD with a longword,
 112          each of whose bytes is C.  This turns each byte that is C
 113          into a zero.  */
 114
 115         /* Each round the main loop processes 16 bytes.  */
 116
 117         ALIGN(4)
 118
 119 L(1):   addl $16, %eax          /* adjust pointer for whole round */
 120
 121 L(11):  movl (%eax), %ecx       /* get word (= 4 bytes) in question */
 122         xorl %edx, %ecx         /* XOR with word c|c|c|c => bytes of str == c
 123                                    are now 0 */
 124         movl $0xfefefeff, %edi  /* magic value */
 125         addl %ecx, %edi         /* add the magic value to the word.  We get
 126                                    carry bits reported for each byte which
 127                                    is *not* C */
 128
 129         /* According to the algorithm we had to reverse the effect of the
 130            XOR first and then test the overflow bits.  But because the
 131            following XOR would destroy the carry flag and it would (in a
 132            representation with more than 32 bits) not alter then last
 133            overflow, we can now test this condition.  If no carry is signaled
 134            no overflow must have occurred in the last byte => it was 0. */
 135         jnc L(7)
 136
 137         /* We are only interested in carry bits that change due to the
 138            previous add, so remove original bits */
 139         xorl %ecx, %edi         /* ((word^charmask)+magic)^(word^charmask) */
 140
 141         /* Now test for the other three overflow bits.  */
 142         orl $0xfefefeff, %edi   /* set all non-carry bits */
 143         incl %edi               /* add 1: if one carry bit was *not* set
 144                                    the addition will not result in 0.  */
 145
 146         /* If at least one byte of the word is C we don't get 0 in %edi.  */
 147         jnz L(7)                /* found it => return pointer */
 148
 149         /* Now we made sure the dword does not contain the character we are
 150            looking for.  But because we deal with strings we have to check
 151            for the end of string before testing the next dword.  */
 152
 153         xorl %edx, %ecx         /* restore original dword without reload */
 154         movl $0xfefefeff, %edi  /* magic value */
 155         addl %ecx, %edi         /* add the magic value to the word.  We get
 156                                    carry bits reported for each byte which
 157                                    is *not* 0 */
 158         jnc L(2)                /* highest byte is NUL => return NULL */
 159         xorl %ecx, %edi         /* (word+magic)^word */
 160         orl $0xfefefeff, %edi   /* set all non-carry bits */
 161         incl %edi               /* add 1: if one carry bit was *not* set
 162                                    the addition will not result in 0.  */
 163         jnz L(2)                /* found NUL => return NULL */
 164
 165         movl 4(%eax), %ecx      /* get word (= 4 bytes) in question */
 166         xorl %edx, %ecx         /* XOR with word c|c|c|c => bytes of str == c
 167                                    are now 0 */
 168         movl $0xfefefeff, %edi  /* magic value */
 169         addl %ecx, %edi         /* add the magic value to the word.  We get
 170                                    carry bits reported for each byte which
 171                                    is *not* C */
 172         jnc L(71)               /* highest byte is C => return pointer */
 173         xorl %ecx, %edi         /* ((word^charmask)+magic)^(word^charmask) */
 174         orl $0xfefefeff, %edi   /* set all non-carry bits */
 175         incl %edi               /* add 1: if one carry bit was *not* set
 176                                    the addition will not result in 0.  */
 177         jnz L(71)               /* found it => return pointer */
 178         xorl %edx, %ecx         /* restore original dword without reload */
 179         movl $0xfefefeff, %edi  /* magic value */
 180         addl %ecx, %edi         /* add the magic value to the word.  We get
 181                                    carry bits reported for each byte which
 182                                    is *not* 0 */
 183         jnc L(2)                /* highest byte is NUL => return NULL */
 184         xorl %ecx, %edi         /* (word+magic)^word */
 185         orl $0xfefefeff, %edi   /* set all non-carry bits */
 186         incl %edi               /* add 1: if one carry bit was *not* set
 187                                    the addition will not result in 0.  */
 188         jnz L(2)                /* found NUL => return NULL */
 189
 190         movl 8(%eax), %ecx      /* get word (= 4 bytes) in question */
 191         xorl %edx, %ecx         /* XOR with word c|c|c|c => bytes of str == c
 192                                    are now 0 */
 193         movl $0xfefefeff, %edi  /* magic value */
 194         addl %ecx, %edi         /* add the magic value to the word.  We get
 195                                    carry bits reported for each byte which
 196                                    is *not* C */
 197         jnc L(72)               /* highest byte is C => return pointer */
 198         xorl %ecx, %edi         /* ((word^charmask)+magic)^(word^charmask) */
 199         orl $0xfefefeff, %edi   /* set all non-carry bits */
 200         incl %edi               /* add 1: if one carry bit was *not* set
 201                                    the addition will not result in 0.  */
 202         jnz L(72)               /* found it => return pointer */
 203         xorl %edx, %ecx         /* restore original dword without reload */
 204         movl $0xfefefeff, %edi  /* magic value */
 205         addl %ecx, %edi         /* add the magic value to the word.  We get
 206                                    carry bits reported for each byte which
 207                                    is *not* 0 */
 208         jnc L(2)                /* highest byte is NUL => return NULL */
 209         xorl %ecx, %edi         /* (word+magic)^word */
 210         orl $0xfefefeff, %edi   /* set all non-carry bits */
 211         incl %edi               /* add 1: if one carry bit was *not* set
 212                                    the addition will not result in 0.  */
 213         jnz L(2)                /* found NUL => return NULL */
 214
 215         movl 12(%eax), %ecx     /* get word (= 4 bytes) in question */
 216         xorl %edx, %ecx         /* XOR with word c|c|c|c => bytes of str == c
 217                                    are now 0 */
 218         movl $0xfefefeff, %edi  /* magic value */
 219         addl %ecx, %edi         /* add the magic value to the word.  We get
 220                                    carry bits reported for each byte which
 221                                    is *not* C */
 222         jnc L(73)               /* highest byte is C => return pointer */
 223         xorl %ecx, %edi         /* ((word^charmask)+magic)^(word^charmask) */
 224         orl $0xfefefeff, %edi   /* set all non-carry bits */
 225         incl %edi               /* add 1: if one carry bit was *not* set
 226                                    the addition will not result in 0.  */
 227         jnz L(73)               /* found it => return pointer */
 228         xorl %edx, %ecx         /* restore original dword without reload */
 229         movl $0xfefefeff, %edi  /* magic value */
 230         addl %ecx, %edi         /* add the magic value to the word.  We get
 231                                    carry bits reported for each byte which
 232                                    is *not* 0 */
 233         jnc L(2)                /* highest byte is NUL => return NULL */
 234         xorl %ecx, %edi         /* (word+magic)^word */
 235         orl $0xfefefeff, %edi   /* set all non-carry bits */
 236         incl %edi               /* add 1: if one carry bit was *not* set
 237                                    the addition will not result in 0.  */
 238         jz L(1)                 /* no NUL found => restart loop */
 239
 240 L(2):   /* Return NULL.  */
 241         xorl %eax, %eax
 242         popl %edi               /* restore saved register content */
 243         cfi_adjust_cfa_offset (-4)
 244         cfi_restore (edi)
 245
 246         ret
 247
 248         cfi_adjust_cfa_offset (4)
 249         cfi_rel_offset (edi, 0)
 250 L(73):  addl $4, %eax           /* adjust pointer */
 251 L(72):  addl $4, %eax
 252 L(71):  addl $4, %eax
 253
 254         /* We now scan for the byte in which the character was matched.
 255            But we have to take care of the case that a NUL char is
 256            found before this in the dword.  Note that we XORed %ecx
 257            with the byte we're looking for, therefore the tests below look
 258            reversed.  */
 259
 260 L(7):   testb %cl, %cl          /* is first byte C? */
 261         jz L(6)                 /* yes => return pointer */
 262         cmpb %dl, %cl           /* is first byte NUL? */
 263         je L(2)                 /* yes => return NULL */
 264         incl %eax               /* it's not in the first byte */
 265
 266         testb %ch, %ch          /* is second byte C? */
 267         jz L(6)                 /* yes => return pointer */
 268         cmpb %dl, %ch           /* is second byte NUL? */
 269         je L(2)                 /* yes => return NULL? */
 270         incl %eax               /* it's not in the second byte */
 271
 272         shrl $16, %ecx          /* make upper byte accessible */
 273         testb %cl, %cl          /* is third byte C? */
 274         jz L(6)                 /* yes => return pointer */
 275         cmpb %dl, %cl           /* is third byte NUL? */
 276         je L(2)                 /* yes => return NULL */
 277
 278         /* It must be in the fourth byte and it cannot be NUL.  */
 279         incl %eax
 280
 281 L(6):
 282         popl %edi               /* restore saved register content */
 283         cfi_adjust_cfa_offset (-4)
 284         cfi_restore (edi)
 285
 286         ret
 287 END (strchr)
 288
 289 weak_alias (strchr, index)
 290 libc_hidden_builtin_def (strchr)