Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Most of the string-functions are rather heavily hand-optimized,
4 * see especially strsep,strstr,str[c]spn. They should work, but are not
5 * very easy to understand. Everything is done entirely within the register
6 * set, making the functions fast and clean. String instructions have been
7 * used through-out, making for "slightly" unclear code :-)
8 *
9 * AK: On P4 and K7 using non string instruction implementations might be faster
10 * for large memory blocks. But most of them are unlikely to be used on large
11 * strings.
12 */
13
14#define __NO_FORTIFY
15#include <linux/string.h>
16#include <linux/export.h>
17
18#ifdef __HAVE_ARCH_STRCPY
19char *strcpy(char *dest, const char *src)
20{
21 int d0, d1, d2;
22 asm volatile("1:\tlodsb\n\t"
23 "stosb\n\t"
24 "testb %%al,%%al\n\t"
25 "jne 1b"
26 : "=&S" (d0), "=&D" (d1), "=&a" (d2)
27 : "0" (src), "1" (dest) : "memory");
28 return dest;
29}
30EXPORT_SYMBOL(strcpy);
31#endif
32
33#ifdef __HAVE_ARCH_STRNCPY
34char *strncpy(char *dest, const char *src, size_t count)
35{
36 int d0, d1, d2, d3;
37 asm volatile("1:\tdecl %2\n\t"
38 "js 2f\n\t"
39 "lodsb\n\t"
40 "stosb\n\t"
41 "testb %%al,%%al\n\t"
42 "jne 1b\n\t"
43 "rep\n\t"
44 "stosb\n"
45 "2:"
46 : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
47 : "0" (src), "1" (dest), "2" (count) : "memory");
48 return dest;
49}
50EXPORT_SYMBOL(strncpy);
51#endif
52
53#ifdef __HAVE_ARCH_STRCAT
54char *strcat(char *dest, const char *src)
55{
56 int d0, d1, d2, d3;
57 asm volatile("repne\n\t"
58 "scasb\n\t"
59 "decl %1\n"
60 "1:\tlodsb\n\t"
61 "stosb\n\t"
62 "testb %%al,%%al\n\t"
63 "jne 1b"
64 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
65 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu) : "memory");
66 return dest;
67}
68EXPORT_SYMBOL(strcat);
69#endif
70
71#ifdef __HAVE_ARCH_STRNCAT
72char *strncat(char *dest, const char *src, size_t count)
73{
74 int d0, d1, d2, d3;
75 asm volatile("repne\n\t"
76 "scasb\n\t"
77 "decl %1\n\t"
78 "movl %8,%3\n"
79 "1:\tdecl %3\n\t"
80 "js 2f\n\t"
81 "lodsb\n\t"
82 "stosb\n\t"
83 "testb %%al,%%al\n\t"
84 "jne 1b\n"
85 "2:\txorl %2,%2\n\t"
86 "stosb"
87 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
88 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu), "g" (count)
89 : "memory");
90 return dest;
91}
92EXPORT_SYMBOL(strncat);
93#endif
94
95#ifdef __HAVE_ARCH_STRCMP
96int strcmp(const char *cs, const char *ct)
97{
98 int d0, d1;
99 int res;
100 asm volatile("1:\tlodsb\n\t"
101 "scasb\n\t"
102 "jne 2f\n\t"
103 "testb %%al,%%al\n\t"
104 "jne 1b\n\t"
105 "xorl %%eax,%%eax\n\t"
106 "jmp 3f\n"
107 "2:\tsbbl %%eax,%%eax\n\t"
108 "orb $1,%%al\n"
109 "3:"
110 : "=a" (res), "=&S" (d0), "=&D" (d1)
111 : "1" (cs), "2" (ct)
112 : "memory");
113 return res;
114}
115EXPORT_SYMBOL(strcmp);
116#endif
117
118#ifdef __HAVE_ARCH_STRNCMP
119int strncmp(const char *cs, const char *ct, size_t count)
120{
121 int res;
122 int d0, d1, d2;
123 asm volatile("1:\tdecl %3\n\t"
124 "js 2f\n\t"
125 "lodsb\n\t"
126 "scasb\n\t"
127 "jne 3f\n\t"
128 "testb %%al,%%al\n\t"
129 "jne 1b\n"
130 "2:\txorl %%eax,%%eax\n\t"
131 "jmp 4f\n"
132 "3:\tsbbl %%eax,%%eax\n\t"
133 "orb $1,%%al\n"
134 "4:"
135 : "=a" (res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
136 : "1" (cs), "2" (ct), "3" (count)
137 : "memory");
138 return res;
139}
140EXPORT_SYMBOL(strncmp);
141#endif
142
143#ifdef __HAVE_ARCH_STRCHR
144char *strchr(const char *s, int c)
145{
146 int d0;
147 char *res;
148 asm volatile("movb %%al,%%ah\n"
149 "1:\tlodsb\n\t"
150 "cmpb %%ah,%%al\n\t"
151 "je 2f\n\t"
152 "testb %%al,%%al\n\t"
153 "jne 1b\n\t"
154 "movl $1,%1\n"
155 "2:\tmovl %1,%0\n\t"
156 "decl %0"
157 : "=a" (res), "=&S" (d0)
158 : "1" (s), "0" (c)
159 : "memory");
160 return res;
161}
162EXPORT_SYMBOL(strchr);
163#endif
164
165#ifdef __HAVE_ARCH_STRLEN
166size_t strlen(const char *s)
167{
168 int d0;
169 size_t res;
170 asm volatile("repne\n\t"
171 "scasb"
172 : "=c" (res), "=&D" (d0)
173 : "1" (s), "a" (0), "0" (0xffffffffu)
174 : "memory");
175 return ~res - 1;
176}
177EXPORT_SYMBOL(strlen);
178#endif
179
180#ifdef __HAVE_ARCH_MEMCHR
181void *memchr(const void *cs, int c, size_t count)
182{
183 int d0;
184 void *res;
185 if (!count)
186 return NULL;
187 asm volatile("repne\n\t"
188 "scasb\n\t"
189 "je 1f\n\t"
190 "movl $1,%0\n"
191 "1:\tdecl %0"
192 : "=D" (res), "=&c" (d0)
193 : "a" (c), "0" (cs), "1" (count)
194 : "memory");
195 return res;
196}
197EXPORT_SYMBOL(memchr);
198#endif
199
200#ifdef __HAVE_ARCH_MEMSCAN
201void *memscan(void *addr, int c, size_t size)
202{
203 if (!size)
204 return addr;
205 asm volatile("repnz; scasb\n\t"
206 "jnz 1f\n\t"
207 "dec %%edi\n"
208 "1:"
209 : "=D" (addr), "=c" (size)
210 : "0" (addr), "1" (size), "a" (c)
211 : "memory");
212 return addr;
213}
214EXPORT_SYMBOL(memscan);
215#endif
216
217#ifdef __HAVE_ARCH_STRNLEN
218size_t strnlen(const char *s, size_t count)
219{
220 int d0;
221 int res;
222 asm volatile("movl %2,%0\n\t"
223 "jmp 2f\n"
224 "1:\tcmpb $0,(%0)\n\t"
225 "je 3f\n\t"
226 "incl %0\n"
227 "2:\tdecl %1\n\t"
228 "cmpl $-1,%1\n\t"
229 "jne 1b\n"
230 "3:\tsubl %2,%0"
231 : "=a" (res), "=&d" (d0)
232 : "c" (s), "1" (count)
233 : "memory");
234 return res;
235}
236EXPORT_SYMBOL(strnlen);
237#endif
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Most of the string-functions are rather heavily hand-optimized,
4 * see especially strsep,strstr,str[c]spn. They should work, but are not
5 * very easy to understand. Everything is done entirely within the register
6 * set, making the functions fast and clean. String instructions have been
7 * used through-out, making for "slightly" unclear code :-)
8 *
9 * AK: On P4 and K7 using non string instruction implementations might be faster
10 * for large memory blocks. But most of them are unlikely to be used on large
11 * strings.
12 */
13
14#include <linux/string.h>
15#include <linux/export.h>
16
17#ifdef __HAVE_ARCH_STRCPY
18char *strcpy(char *dest, const char *src)
19{
20 int d0, d1, d2;
21 asm volatile("1:\tlodsb\n\t"
22 "stosb\n\t"
23 "testb %%al,%%al\n\t"
24 "jne 1b"
25 : "=&S" (d0), "=&D" (d1), "=&a" (d2)
26 : "0" (src), "1" (dest) : "memory");
27 return dest;
28}
29EXPORT_SYMBOL(strcpy);
30#endif
31
32#ifdef __HAVE_ARCH_STRNCPY
33char *strncpy(char *dest, const char *src, size_t count)
34{
35 int d0, d1, d2, d3;
36 asm volatile("1:\tdecl %2\n\t"
37 "js 2f\n\t"
38 "lodsb\n\t"
39 "stosb\n\t"
40 "testb %%al,%%al\n\t"
41 "jne 1b\n\t"
42 "rep\n\t"
43 "stosb\n"
44 "2:"
45 : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
46 : "0" (src), "1" (dest), "2" (count) : "memory");
47 return dest;
48}
49EXPORT_SYMBOL(strncpy);
50#endif
51
52#ifdef __HAVE_ARCH_STRCAT
53char *strcat(char *dest, const char *src)
54{
55 int d0, d1, d2, d3;
56 asm volatile("repne\n\t"
57 "scasb\n\t"
58 "decl %1\n"
59 "1:\tlodsb\n\t"
60 "stosb\n\t"
61 "testb %%al,%%al\n\t"
62 "jne 1b"
63 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
64 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu) : "memory");
65 return dest;
66}
67EXPORT_SYMBOL(strcat);
68#endif
69
70#ifdef __HAVE_ARCH_STRNCAT
71char *strncat(char *dest, const char *src, size_t count)
72{
73 int d0, d1, d2, d3;
74 asm volatile("repne\n\t"
75 "scasb\n\t"
76 "decl %1\n\t"
77 "movl %8,%3\n"
78 "1:\tdecl %3\n\t"
79 "js 2f\n\t"
80 "lodsb\n\t"
81 "stosb\n\t"
82 "testb %%al,%%al\n\t"
83 "jne 1b\n"
84 "2:\txorl %2,%2\n\t"
85 "stosb"
86 : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
87 : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu), "g" (count)
88 : "memory");
89 return dest;
90}
91EXPORT_SYMBOL(strncat);
92#endif
93
94#ifdef __HAVE_ARCH_STRCMP
95int strcmp(const char *cs, const char *ct)
96{
97 int d0, d1;
98 int res;
99 asm volatile("1:\tlodsb\n\t"
100 "scasb\n\t"
101 "jne 2f\n\t"
102 "testb %%al,%%al\n\t"
103 "jne 1b\n\t"
104 "xorl %%eax,%%eax\n\t"
105 "jmp 3f\n"
106 "2:\tsbbl %%eax,%%eax\n\t"
107 "orb $1,%%al\n"
108 "3:"
109 : "=a" (res), "=&S" (d0), "=&D" (d1)
110 : "1" (cs), "2" (ct)
111 : "memory");
112 return res;
113}
114EXPORT_SYMBOL(strcmp);
115#endif
116
117#ifdef __HAVE_ARCH_STRNCMP
118int strncmp(const char *cs, const char *ct, size_t count)
119{
120 int res;
121 int d0, d1, d2;
122 asm volatile("1:\tdecl %3\n\t"
123 "js 2f\n\t"
124 "lodsb\n\t"
125 "scasb\n\t"
126 "jne 3f\n\t"
127 "testb %%al,%%al\n\t"
128 "jne 1b\n"
129 "2:\txorl %%eax,%%eax\n\t"
130 "jmp 4f\n"
131 "3:\tsbbl %%eax,%%eax\n\t"
132 "orb $1,%%al\n"
133 "4:"
134 : "=a" (res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
135 : "1" (cs), "2" (ct), "3" (count)
136 : "memory");
137 return res;
138}
139EXPORT_SYMBOL(strncmp);
140#endif
141
142#ifdef __HAVE_ARCH_STRCHR
143char *strchr(const char *s, int c)
144{
145 int d0;
146 char *res;
147 asm volatile("movb %%al,%%ah\n"
148 "1:\tlodsb\n\t"
149 "cmpb %%ah,%%al\n\t"
150 "je 2f\n\t"
151 "testb %%al,%%al\n\t"
152 "jne 1b\n\t"
153 "movl $1,%1\n"
154 "2:\tmovl %1,%0\n\t"
155 "decl %0"
156 : "=a" (res), "=&S" (d0)
157 : "1" (s), "0" (c)
158 : "memory");
159 return res;
160}
161EXPORT_SYMBOL(strchr);
162#endif
163
164#ifdef __HAVE_ARCH_STRLEN
165size_t strlen(const char *s)
166{
167 int d0;
168 size_t res;
169 asm volatile("repne\n\t"
170 "scasb"
171 : "=c" (res), "=&D" (d0)
172 : "1" (s), "a" (0), "0" (0xffffffffu)
173 : "memory");
174 return ~res - 1;
175}
176EXPORT_SYMBOL(strlen);
177#endif
178
179#ifdef __HAVE_ARCH_MEMCHR
180void *memchr(const void *cs, int c, size_t count)
181{
182 int d0;
183 void *res;
184 if (!count)
185 return NULL;
186 asm volatile("repne\n\t"
187 "scasb\n\t"
188 "je 1f\n\t"
189 "movl $1,%0\n"
190 "1:\tdecl %0"
191 : "=D" (res), "=&c" (d0)
192 : "a" (c), "0" (cs), "1" (count)
193 : "memory");
194 return res;
195}
196EXPORT_SYMBOL(memchr);
197#endif
198
199#ifdef __HAVE_ARCH_MEMSCAN
200void *memscan(void *addr, int c, size_t size)
201{
202 if (!size)
203 return addr;
204 asm volatile("repnz; scasb\n\t"
205 "jnz 1f\n\t"
206 "dec %%edi\n"
207 "1:"
208 : "=D" (addr), "=c" (size)
209 : "0" (addr), "1" (size), "a" (c)
210 : "memory");
211 return addr;
212}
213EXPORT_SYMBOL(memscan);
214#endif
215
216#ifdef __HAVE_ARCH_STRNLEN
217size_t strnlen(const char *s, size_t count)
218{
219 int d0;
220 int res;
221 asm volatile("movl %2,%0\n\t"
222 "jmp 2f\n"
223 "1:\tcmpb $0,(%0)\n\t"
224 "je 3f\n\t"
225 "incl %0\n"
226 "2:\tdecl %1\n\t"
227 "cmpl $-1,%1\n\t"
228 "jne 1b\n"
229 "3:\tsubl %2,%0"
230 : "=a" (res), "=&d" (d0)
231 : "c" (s), "1" (count)
232 : "memory");
233 return res;
234}
235EXPORT_SYMBOL(strnlen);
236#endif