string/strncmp.c

   1 /* Copyright (C) 1991-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <stdint.h>
  19 #include <string-fzb.h>
  20 #include <string-fzc.h>
  21 #include <string-fzi.h>
  22 #include <string.h>
  23 #include <sys/param.h>
  24 #include <memcopy.h>
  25
  26 #undef strncmp
  27
  28 #ifndef STRNCMP
  29 #define STRNCMP strncmp
  30 #endif
  31
  32 static inline int
  33 final_cmp (const op_t w1, const op_t w2, size_t n)
  34 {
  35   unsigned int idx = index_first_zero_ne (w1, w2);
  36   if (n <= idx)
  37     return 0;
  38   return extractbyte (w1, idx) - extractbyte (w2, idx);
  39 }
  40
  41 /* Aligned loop: if a difference is found, exit to compare the bytes.  Else
  42    if a zero is found we have equal strings.  */
  43 static inline int
  44 strncmp_aligned_loop (const op_t *x1, const op_t *x2, op_t w1, size_t n)
  45 {
  46   op_t w2 = *x2++;
  47
  48   while (w1 == w2)
  49     {
  50       if (n <= sizeof (op_t))
  51         break;
  52       n -= sizeof (op_t);
  53
  54       if (has_zero (w1))
  55         return 0;
  56       w1 = *x1++;
  57       w2 = *x2++;
  58     }
  59
  60   return final_cmp (w1, w2, n);
  61 }
  62
  63 /* Unaligned loop: align the first partial of P2, with 0xff for the rest of
  64    the bytes so that we can also apply the has_zero test to see if we have
  65    already reached EOS.  If we have, then we can simply fall through to the
  66    final comparison.  */
  67 static inline int
  68 strncmp_unaligned_loop (const op_t *x1, const op_t *x2, op_t w1, uintptr_t ofs,
  69                         size_t n)
  70 {
  71   op_t w2a = *x2++;
  72   uintptr_t sh_1 = ofs * CHAR_BIT;
  73   uintptr_t sh_2 = sizeof(op_t) * CHAR_BIT - sh_1;
  74
  75   op_t w2 = MERGE (w2a, sh_1, (op_t)-1, sh_2);
  76   if (!has_zero (w2) && n > (sizeof (op_t) - ofs))
  77     {
  78       op_t w2b;
  79
  80       /* Unaligned loop.  The invariant is that W2B, which is "ahead" of W1,
  81          does not contain end-of-string.  Therefore it is safe (and necessary)
  82          to read another word from each while we do not have a difference.  */
  83       while (1)
  84         {
  85           w2b = *x2++;
  86           w2 = MERGE (w2a, sh_1, w2b, sh_2);
  87           if (n <= sizeof (op_t) || w1 != w2)
  88             return final_cmp (w1, w2, n);
  89           n -= sizeof(op_t);
  90           if (has_zero (w2b) || n <= (sizeof (op_t) - ofs))
  91             break;
  92           w1 = *x1++;
  93           w2a = w2b;
  94         }
  95
  96       /* Zero found in the second partial of P2.  If we had EOS in the aligned
  97          word, we have equality.  */
  98       if (has_zero (w1))
  99         return 0;
 100
 101       /* Load the final word of P1 and align the final partial of P2.  */
 102       w1 = *x1++;
 103       w2 = MERGE (w2b, sh_1, 0, sh_2);
 104     }
 105
 106   return final_cmp (w1, w2, n);
 107 }
 108
 109 /* Compare no more than N characters of S1 and S2,
 110    returning less than, equal to or greater than zero
 111    if S1 is lexicographically less than, equal to or
 112    greater than S2.  */
 113 int
 114 STRNCMP (const char *p1, const char *p2, size_t n)
 115 {
 116   /* Handle the unaligned bytes of p1 first.  */
 117   uintptr_t a = MIN (-(uintptr_t)p1 % sizeof(op_t), n);
 118   int diff = 0;
 119   for (int i = 0; i < a; ++i)
 120     {
 121       unsigned char c1 = *p1++;
 122       unsigned char c2 = *p2++;
 123       diff = c1 - c2;
 124       if (c1 == '\0' || diff != 0)
 125         return diff;
 126     }
 127   if (a == n)
 128     return 0;
 129
 130   /* P1 is now aligned to op_t.  P2 may or may not be.  */
 131   const op_t *x1 = (const op_t *) p1;
 132   op_t w1 = *x1++;
 133   uintptr_t ofs = (uintptr_t) p2 % sizeof(op_t);
 134   return ofs == 0
 135     ? strncmp_aligned_loop (x1, (const op_t *) p2, w1, n - a)
 136     : strncmp_unaligned_loop (x1, (const op_t *) (p2 - ofs), w1, ofs, n - a);
 137 }
 138 libc_hidden_builtin_def (STRNCMP)