1 | /* Copyright (C) 1991-2024 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 (x1: w1, x2: w2); |
36 | if (n <= idx) |
37 | return 0; |
38 | return extractbyte (x: w1, idx) - extractbyte (x: 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 (x: 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 (x: 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 (x: 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 (x: 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, x2: (const op_t *) p2, w1, n: n - a) |
136 | : strncmp_unaligned_loop (x1, x2: (const op_t *) (p2 - ofs), w1, ofs, n: n - a); |
137 | } |
138 | libc_hidden_builtin_def (STRNCMP) |
139 | |