sysdeps/powerpc/powerpc64/power7/memchr.S

   1 /* Optimized memchr implementation for PowerPC64/POWER7 using cmpb insn.
   2    Copyright (C) 2010 Free Software Foundation, Inc.
   3    Contributed by Luis Machado <luisgpm@br.ibm.com>.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <sysdep.h>
  21 #include <bp-sym.h>
  22 #include <bp-asm.h>
  23
  24 /* int [r3] memchr (char *s [r3], int byte [r4], int size [r5])  */
  25         .machine  power7
  26 ENTRY (BP_SYM (__memchr))
  27         CALL_MCOUNT 2
  28         dcbt    0,r3
  29         clrrdi  r8,r3,3
  30         rlwimi  r4,r4,8,16,23
  31         rlwimi  r4,r4,16,0,15
  32         insrdi  r4,r4,32,0
  33         add     r7,r3,r5      /* Calculate the last acceptable address.  */
  34         cmpldi  r5,32
  35         ble     L(small_range)
  36
  37         cmpld   cr7,r3,r7     /* Is the address equal or less than r3?  If
  38                                  it's equal or less, it means size is either 0
  39                                  or a negative number.  */
  40         ble     cr7,L(proceed)
  41
  42         li      r7,-1         /* Make r11 the biggest if r4 <= 0.  */
  43 L(proceed):
  44         rlwinm  r6,r3,3,26,28 /* Calculate padding.  */
  45         ld      r12,0(r8)     /* Load doubleword from memory.  */
  46         cmpb    r10,r12,r4    /* Check for BYTE's in DWORD1.  */
  47         sld     r10,r10,r6
  48         srd     r10,r10,r6
  49         cmpldi  cr7,r10,0     /* If r10 == 0, no BYTE's's have been found.  */
  50         bne     cr7,L(done)
  51
  52         /* Are we done already?  */
  53         addi    r9,r8,8
  54         cmpld   cr6,r9,r7
  55         bge     cr6,L(null)
  56
  57         mtcrf   0x01,r8
  58         /* Are we now aligned to a quadword boundary?  If so, skip to
  59            the main loop.  Otherwise, go through the alignment code.  */
  60
  61         bt      28,L(loop_setup)
  62
  63         /* Handle DWORD2 of pair.  */
  64         ldu     r12,8(r8)
  65         cmpb    r10,r12,r4
  66         cmpldi  cr7,r10,0
  67         bne     cr7,L(done)
  68
  69         /* Are we done already?  */
  70         addi    r9,r8,8
  71         cmpld   cr6,r9,r7
  72         bge     cr6,L(null)
  73
  74 L(loop_setup):
  75         sub     r5,r7,r9
  76         srdi    r6,r5,4       /* Number of loop iterations.  */
  77         mtctr   r6            /* Setup the counter.  */
  78         b       L(loop)
  79         /* Main loop to look for BYTE backwards in the string.  Since
  80            it's a small loop (< 8 instructions), align it to 32-bytes.  */
  81         .p2align  5
  82 L(loop):
  83         /* Load two doublewords, compare and merge in a
  84            single register for speed.  This is an attempt
  85            to speed up the byte-checking process for bigger strings.  */
  86
  87         ld      r12,8(r8)
  88         ldu     r11,16(r8)
  89         cmpb    r10,r12,r4
  90         cmpb    r9,r11,r4
  91         or      r5,r9,r10     /* Merge everything in one doubleword.  */
  92         cmpldi  cr7,r5,0
  93         bne     cr7,L(found)
  94         bdnz    L(loop)
  95         /* We're here because the counter reached 0, and that means we
  96            didn't have any matches for BYTE in the whole range.  Just return
  97            the original range.  */
  98         addi    r9,r8,8
  99         cmpld   cr6,r9,r7
 100         blt     cr6,L(loop_small)
 101         b       L(null)
 102
 103         /* OK, one (or both) of the doublewords contains BYTE.  Check
 104            the first doubleword and decrement the address in case the first
 105            doubleword really contains BYTE.  */
 106         .align  4
 107 L(found):
 108         cmpldi  cr6,r10,0
 109         addi    r8,r8,-8
 110         bne     cr6,L(done)
 111
 112         /* BYTE must be in the second doubleword.  Adjust the address
 113            again and move the result of cmpb to r10 so we can calculate the
 114            pointer.  */
 115
 116         mr      r10,r9
 117         addi    r8,r8,8
 118
 119         /* r10 has the output of the cmpb instruction, that is, it contains
 120            0xff in the same position as BYTE in the original
 121            doubleword from the string.  Use that to calculate the pointer.
 122            We need to make sure BYTE is *before* the end of the
 123            range.  */
 124 L(done):
 125         cntlzd  r0,r10        /* Count leading zeroes before the match.  */
 126         srdi    r0,r0,3       /* Convert leading zeroes to bytes.  */
 127         add     r3,r8,r0
 128         cmpld   r3,r7
 129         bge     L(null)
 130         blr
 131
 132         .align  4
 133 L(null):
 134         li      r3,0
 135         blr
 136
 137 /* Deals with size <= 32.  */
 138         .align  4
 139 L(small_range):
 140         cmpldi  r5,0
 141         beq     L(null)
 142
 143         rlwinm  r6,r3,3,26,28 /* Calculate padding.  */
 144         ld      r12,0(r8)     /* Load word from memory.  */
 145         cmpb    r10,r12,r4    /* Check for BYTE in DWORD1.  */
 146         sld     r10,r10,r6
 147         srd     r10,r10,r6
 148         cmpldi  cr7,r10,0
 149         bne     cr7,L(done)
 150
 151         /* Are we done already?  */
 152         addi    r9,r8,8
 153         cmpld   r9,r7
 154         bge     L(null)
 155         b       L(loop_small)
 156
 157         .p2align  5
 158 L(loop_small):
 159         ldu     r12,8(r8)
 160         cmpb    r10,r12,r4
 161         addi    r9,r8,8
 162         cmpldi  cr6,r10,0
 163         bne     cr6,L(done)
 164         cmpld   r9,r7
 165         bge     L(null)
 166         b       L(loop_small)
 167
 168 END (BP_SYM (__memchr))
 169 weak_alias (BP_SYM (__memchr), BP_SYM(memchr))
 170 libc_hidden_builtin_def (memchr)