sysdeps/alpha/strcmp.S

   1 /* Copyright (C) 1996 Free Software Foundation, Inc.
   2    Contributed by Richard Henderson (rth@tamu.edu)
   3
   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 Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    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    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If
  18    not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  19    Cambridge, MA 02139, USA.  */
  20
  21 /* Bytewise compare two null-terminated strings.  */
  22
  23 #include <sysdep.h>
  24
  25         .set noat
  26         .set noreorder
  27
  28         .text
  29
  30 ENTRY(strcmp)
  31 #ifdef PROF
  32         ldgp    gp, 0(pv)
  33         lda     AT, _mcount
  34         jmp     AT, (AT), _mcount
  35         .prologue 1
  36 #else
  37         .prologue 0
  38 #endif
  39
  40         ldq_u   t0, 0(a0)       # e0    : give cache time to catch up
  41         xor     a0, a1, t2      # .. e1 : are s1 and s2 co-aligned?
  42         ldq_u   t1, 0(a1)       # e0    :
  43         and     t2, 7, t2       # .. e1 :
  44         lda     t3, -1          # e0    :
  45         bne     t2, $unaligned  # .. e1 :
  46
  47         /* On entry to this basic block:
  48            t0 == the first destination word for masking back in
  49            t1 == the first source word.
  50            t3 == -1.  */
  51
  52 $aligned:
  53         mskqh   t3, a0, t3      # e0    :
  54         nop                     # .. e1 :
  55         ornot   t1, t3, t1      # e0    :
  56         ornot   t0, t3, t0      # .. e1 :
  57         cmpbge  zero, t1, t7    # e0    : bits set iff null found
  58         bne     t7, $eos        # e1 (zdb)
  59
  60         /* Aligned compare main loop.
  61            On entry to this basic block:
  62            t0 == an s1 word.
  63            t1 == an s2 word not containing a null.  */
  64
  65 $a_loop:
  66         xor     t0, t1, t2      # e0    :
  67         bne     t2, $wordcmp    # .. e1 (zdb)
  68         ldq_u   t1, 8(a1)       # e0    :
  69         ldq_u   t0, 8(a0)       # .. e1 :
  70         addq    a1, 8, a1       # e0    :
  71         addq    a0, 8, a0       # .. e1 :
  72         cmpbge  zero, t1, t7    # e0    :
  73         beq     t7, $a_loop     # .. e1 (zdb)
  74         br      $eos            # e1    :
  75
  76         /* The two strings are not co-aligned.  Align s1 and cope.  */
  77
  78 $unaligned:
  79         and     a0, 7, t4       # e0    : find s1 misalignment
  80         and     a1, 7, t5       # .. e1 : find s2 misalignment
  81         subq    a1, t4, a1      # e0    :
  82
  83         /* If s2 misalignment is larger than s2 misalignment, we need
  84            extra startup checks to avoid SEGV.  */
  85
  86         cmplt   t4, t5, t8      # .. e1 :
  87         beq     t8, $u_head     # e1    :
  88
  89         mskqh   t3, t5, t3      # e0    :
  90         ornot   t1, t3, t3      # e0    :
  91         cmpbge  zero, t3, t7    # e1    : is there a zero?
  92         beq     t7, $u_head     # e1    :
  93
  94         /* We've found a zero in the first partial word of s2.  Align
  95            our current s1 and s2 words and compare what we've got.  */
  96
  97         extql   t1, t5, t1      # e0    :
  98         extql   t0, a0, t0      # e0    :
  99         cmpbge  zero, t1, t7    # .. e1 : find that zero again
 100         br      $eos            # e1    : and finish up
 101
 102         .align 3
 103 $u_head:
 104         /* We know just enough now to be able to assemble the first
 105            full word of s2.  We can still find a zero at the end of it.
 106
 107            On entry to this basic block:
 108            t0 == first word of s1
 109            t1 == first partial word of s2.  */
 110
 111         ldq_u   t2, 8(a1)       # e0    : load second partial s2 word
 112         lda     t3, -1          # .. e1 : create leading garbage mask
 113         extql   t1, a1, t1      # e0    : create first s2 word
 114         mskqh   t3, a0, t3      # e0    :
 115         extqh   t2, a1, t4      # e0    :
 116         ornot   t0, t3, t0      # .. e1 : kill s1 garbage
 117         or      t1, t4, t1      # e0    : s2 word now complete
 118         cmpbge  zero, t0, t7    # .. e1 : find zero in first s1 word
 119         ornot   t1, t3, t1      # e0    : kill s2 garbage
 120         lda     t3, -1          # .. e1 :
 121         mskql   t3, a1, t3      # e0    : mask for s2[1] bits we have seen
 122         bne     t7, $eos        # .. e1 :
 123         xor     t0, t1, t4      # e0    : compare aligned words
 124         bne     t4, $wordcmp    # .. e1 (zdb)
 125         or      t2, t3, t3      # e0    :
 126         cmpbge  zero, t3, t7    # e1    :
 127         bne     t7, $u_final    # e1    :
 128
 129         /* Unaligned copy main loop.  In order to avoid reading too much,
 130            the loop is structured to detect zeros in aligned words from s2.
 131            This has, unfortunately, effectively pulled half of a loop
 132            iteration out into the head and half into the tail, but it does
 133            prevent nastiness from accumulating in the very thing we want
 134            to run as fast as possible.
 135
 136            On entry to this basic block:
 137            t2 == the unshifted low-bits from the next s2 word.  */
 138
 139         .align 3
 140 $u_loop:
 141         extql   t2, a1, t3      # e0    :
 142         ldq_u   t2, 16(a1)      # .. e1 : load next s2 high bits
 143         ldq_u   t0, 8(a0)       # e0    : load next s1 word
 144         addq    a1, 8, a1       # .. e1 :
 145         addq    a0, 8, a0       # e0    :
 146         nop                     # .. e1 :
 147         extqh   t2, a1, t1      # e0    :
 148         cmpbge  zero, t0, t7    # .. e1 : find zero in current s1 word
 149         or      t1, t3, t1      # e0    :
 150         bne     t7, $eos        # .. e1 :
 151         xor     t0, t1, t4      # e0    : compare the words
 152         bne     t4, $wordcmp    # .. e1 (zdb)
 153         cmpbge  zero, t2, t4    # e0    : find zero in next low bits
 154         beq     t4, $u_loop     # .. e1 (zdb)
 155
 156         /* We've found a zero in the low bits of the last s2 word.  Get
 157            the next s1 word and align them.  */
 158 $u_final:
 159         ldq_u   t0, 8(a0)       # e1    :
 160         extql   t2, a1, t1      # .. e0 :
 161         cmpbge  zero, t1, t7    # e0    :
 162
 163         /* We've found a zero somewhere in a word we just read.
 164            On entry to this basic block:
 165            t0 == s1 word
 166            t1 == s2 word
 167            t7 == cmpbge mask containing the zero.  */
 168
 169         .align 3
 170 $eos:
 171         negq    t7, t6          # e0    : create bytemask of valid data
 172         and     t6, t7, t8      # e1    :
 173         subq    t8, 1, t6       # e0    :
 174         or      t6, t8, t7      # e1    :
 175         zapnot  t0, t7, t0      # e0    : kill the garbage
 176         zapnot  t1, t7, t1      # .. e1 :
 177         xor     t0, t1, v0      # e0    : and compare
 178         beq     v0, $done       # .. e1 :
 179
 180         /* Here we have two differing co-aligned words in t0 & t1.
 181            Bytewise compare them and return (t0 > t1 ? 1 : -1).  */
 182 $wordcmp:
 183         cmpbge  t0, t1, t2      # e0    : comparison yields bit mask of ge
 184         cmpbge  t1, t0, t3      # .. e1 :
 185         xor     t2, t3, t0      # e0    : bits set iff t0/t1 bytes differ
 186         negq    t0, t1          # e1    : clear all but least bit
 187         and     t0, t1, t0      # e0    :
 188         lda     v0, -1          # .. e1 :
 189         and     t0, t2, t1      # e0    : was bit set in t0 > t1?
 190         cmovne  t1, 1, v0       # .. e1 (zdb)
 191
 192 $done:
 193         ret                     # e1    :
 194
 195         END(strcmp)