1 | /* Copyright (C) 2000-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 | /* Copy a null-terminated string from SRC to DST. |
19 | |
20 | This is an internal routine used by strcpy, stpcpy, and strcat. |
21 | As such, it uses special linkage conventions to make implementation |
22 | of these public functions more efficient. |
23 | |
24 | On input: |
25 | t9 = return address |
26 | a0 = DST |
27 | a1 = SRC |
28 | |
29 | On output: |
30 | t8 = bitmask (with one bit set) indicating the last byte written |
31 | a0 = unaligned address of the last *word* written |
32 | |
33 | Furthermore, v0, a3-a5, t11, and t12 are untouched. |
34 | */ |
35 | |
36 | |
37 | #include <sysdep.h> |
38 | |
39 | .arch ev6 |
40 | .set noat |
41 | .set noreorder |
42 | |
43 | .text |
44 | .type __stxcpy, @function |
45 | .globl __stxcpy |
46 | .usepv __stxcpy, no |
47 | |
48 | cfi_startproc |
49 | cfi_return_column (t9) |
50 | |
51 | /* On entry to this basic block: |
52 | t0 == the first destination word for masking back in |
53 | t1 == the first source word. */ |
54 | .align 4 |
55 | stxcpy_aligned: |
56 | /* Create the 1st output word and detect 0's in the 1st input word. */ |
57 | lda t2, -1 # E : build a mask against false zero |
58 | mskqh t2, a1, t2 # U : detection in the src word (stall) |
59 | mskqh t1, a1, t3 # U : |
60 | ornot t1, t2, t2 # E : (stall) |
61 | |
62 | mskql t0, a1, t0 # U : assemble the first output word |
63 | cmpbge zero, t2, t10 # E : bits set iff null found |
64 | or t0, t3, t1 # E : (stall) |
65 | bne t10, $a_eos # U : (stall) |
66 | |
67 | /* On entry to this basic block: |
68 | t0 == the first destination word for masking back in |
69 | t1 == a source word not containing a null. */ |
70 | /* Nops here to separate store quads from load quads */ |
71 | |
72 | $a_loop: |
73 | stq_u t1, 0(a0) # L : |
74 | addq a0, 8, a0 # E : |
75 | nop |
76 | nop |
77 | |
78 | ldq_u t1, 0(a1) # L : Latency=3 |
79 | addq a1, 8, a1 # E : |
80 | cmpbge zero, t1, t10 # E : (3 cycle stall) |
81 | beq t10, $a_loop # U : (stall for t10) |
82 | |
83 | /* Take care of the final (partial) word store. |
84 | On entry to this basic block we have: |
85 | t1 == the source word containing the null |
86 | t10 == the cmpbge mask that found it. */ |
87 | $a_eos: |
88 | negq t10, t6 # E : find low bit set |
89 | and t10, t6, t8 # E : (stall) |
90 | /* For the sake of the cache, don't read a destination word |
91 | if we're not going to need it. */ |
92 | and t8, 0x80, t6 # E : (stall) |
93 | bne t6, 1f # U : (stall) |
94 | |
95 | /* We're doing a partial word store and so need to combine |
96 | our source and original destination words. */ |
97 | ldq_u t0, 0(a0) # L : Latency=3 |
98 | subq t8, 1, t6 # E : |
99 | zapnot t1, t6, t1 # U : clear src bytes >= null (stall) |
100 | or t8, t6, t10 # E : (stall) |
101 | |
102 | zap t0, t10, t0 # E : clear dst bytes <= null |
103 | or t0, t1, t1 # E : (stall) |
104 | nop |
105 | nop |
106 | |
107 | 1: stq_u t1, 0(a0) # L : |
108 | ret (t9) # L0 : Latency=3 |
109 | nop |
110 | nop |
111 | |
112 | .align 4 |
113 | __stxcpy: |
114 | /* Are source and destination co-aligned? */ |
115 | xor a0, a1, t0 # E : |
116 | unop # E : |
117 | and t0, 7, t0 # E : (stall) |
118 | bne t0, $unaligned # U : (stall) |
119 | |
120 | /* We are co-aligned; take care of a partial first word. */ |
121 | ldq_u t1, 0(a1) # L : load first src word |
122 | and a0, 7, t0 # E : take care not to load a word ... |
123 | addq a1, 8, a1 # E : |
124 | beq t0, stxcpy_aligned # U : ... if we wont need it (stall) |
125 | |
126 | ldq_u t0, 0(a0) # L : |
127 | br stxcpy_aligned # L0 : Latency=3 |
128 | nop |
129 | nop |
130 | |
131 | |
132 | /* The source and destination are not co-aligned. Align the destination |
133 | and cope. We have to be very careful about not reading too much and |
134 | causing a SEGV. */ |
135 | |
136 | .align 4 |
137 | $u_head: |
138 | /* We know just enough now to be able to assemble the first |
139 | full source word. We can still find a zero at the end of it |
140 | that prevents us from outputting the whole thing. |
141 | |
142 | On entry to this basic block: |
143 | t0 == the first dest word, for masking back in, if needed else 0 |
144 | t1 == the low bits of the first source word |
145 | t6 == bytemask that is -1 in dest word bytes */ |
146 | |
147 | ldq_u t2, 8(a1) # L : |
148 | addq a1, 8, a1 # E : |
149 | extql t1, a1, t1 # U : (stall on a1) |
150 | extqh t2, a1, t4 # U : (stall on a1) |
151 | |
152 | mskql t0, a0, t0 # U : |
153 | or t1, t4, t1 # E : |
154 | mskqh t1, a0, t1 # U : (stall on t1) |
155 | or t0, t1, t1 # E : (stall on t1) |
156 | |
157 | or t1, t6, t6 # E : |
158 | cmpbge zero, t6, t10 # E : (stall) |
159 | lda t6, -1 # E : for masking just below |
160 | bne t10, $u_final # U : (stall) |
161 | |
162 | mskql t6, a1, t6 # U : mask out the bits we have |
163 | or t6, t2, t2 # E : already extracted before (stall) |
164 | cmpbge zero, t2, t10 # E : testing eos (stall) |
165 | bne t10, $u_late_head_exit # U : (stall) |
166 | |
167 | /* Finally, we've got all the stupid leading edge cases taken care |
168 | of and we can set up to enter the main loop. */ |
169 | |
170 | stq_u t1, 0(a0) # L : store first output word |
171 | addq a0, 8, a0 # E : |
172 | extql t2, a1, t0 # U : position ho-bits of lo word |
173 | ldq_u t2, 8(a1) # U : read next high-order source word |
174 | |
175 | addq a1, 8, a1 # E : |
176 | cmpbge zero, t2, t10 # E : (stall for t2) |
177 | nop # E : |
178 | bne t10, $u_eos # U : (stall) |
179 | |
180 | /* Unaligned copy main loop. In order to avoid reading too much, |
181 | the loop is structured to detect zeros in aligned source words. |
182 | This has, unfortunately, effectively pulled half of a loop |
183 | iteration out into the head and half into the tail, but it does |
184 | prevent nastiness from accumulating in the very thing we want |
185 | to run as fast as possible. |
186 | |
187 | On entry to this basic block: |
188 | t0 == the shifted high-order bits from the previous source word |
189 | t2 == the unshifted current source word |
190 | |
191 | We further know that t2 does not contain a null terminator. */ |
192 | |
193 | .align 3 |
194 | $u_loop: |
195 | extqh t2, a1, t1 # U : extract high bits for current word |
196 | addq a1, 8, a1 # E : (stall) |
197 | extql t2, a1, t3 # U : extract low bits for next time (stall) |
198 | addq a0, 8, a0 # E : |
199 | |
200 | or t0, t1, t1 # E : current dst word now complete |
201 | ldq_u t2, 0(a1) # L : Latency=3 load high word for next time |
202 | stq_u t1, -8(a0) # L : save the current word (stall) |
203 | mov t3, t0 # E : |
204 | |
205 | cmpbge zero, t2, t10 # E : test new word for eos |
206 | beq t10, $u_loop # U : (stall) |
207 | nop |
208 | nop |
209 | |
210 | /* We've found a zero somewhere in the source word we just read. |
211 | If it resides in the lower half, we have one (probably partial) |
212 | word to write out, and if it resides in the upper half, we |
213 | have one full and one partial word left to write out. |
214 | |
215 | On entry to this basic block: |
216 | t0 == the shifted high-order bits from the previous source word |
217 | t2 == the unshifted current source word. */ |
218 | $u_eos: |
219 | extqh t2, a1, t1 # U : |
220 | or t0, t1, t1 # E : first (partial) source word complete (stall) |
221 | cmpbge zero, t1, t10 # E : is the null in this first bit? (stall) |
222 | bne t10, $u_final # U : (stall) |
223 | |
224 | $u_late_head_exit: |
225 | stq_u t1, 0(a0) # L : the null was in the high-order bits |
226 | addq a0, 8, a0 # E : |
227 | extql t2, a1, t1 # U : |
228 | cmpbge zero, t1, t10 # E : (stall) |
229 | |
230 | /* Take care of a final (probably partial) result word. |
231 | On entry to this basic block: |
232 | t1 == assembled source word |
233 | t10 == cmpbge mask that found the null. */ |
234 | $u_final: |
235 | negq t10, t6 # E : isolate low bit set |
236 | and t6, t10, t8 # E : (stall) |
237 | and t8, 0x80, t6 # E : avoid dest word load if we can (stall) |
238 | bne t6, 1f # U : (stall) |
239 | |
240 | ldq_u t0, 0(a0) # E : |
241 | subq t8, 1, t6 # E : |
242 | or t6, t8, t10 # E : (stall) |
243 | zapnot t1, t6, t1 # U : kill source bytes >= null (stall) |
244 | |
245 | zap t0, t10, t0 # U : kill dest bytes <= null (2 cycle data stall) |
246 | or t0, t1, t1 # E : (stall) |
247 | nop |
248 | nop |
249 | |
250 | 1: stq_u t1, 0(a0) # L : |
251 | ret (t9) # L0 : Latency=3 |
252 | nop |
253 | nop |
254 | |
255 | /* Unaligned copy entry point. */ |
256 | .align 4 |
257 | $unaligned: |
258 | |
259 | ldq_u t1, 0(a1) # L : load first source word |
260 | and a0, 7, t4 # E : find dest misalignment |
261 | and a1, 7, t5 # E : find src misalignment |
262 | /* Conditionally load the first destination word and a bytemask |
263 | with 0xff indicating that the destination byte is sacrosanct. */ |
264 | mov zero, t0 # E : |
265 | |
266 | mov zero, t6 # E : |
267 | beq t4, 1f # U : |
268 | ldq_u t0, 0(a0) # L : |
269 | lda t6, -1 # E : |
270 | |
271 | mskql t6, a0, t6 # U : |
272 | nop |
273 | nop |
274 | nop |
275 | 1: |
276 | subq a1, t4, a1 # E : sub dest misalignment from src addr |
277 | /* If source misalignment is larger than dest misalignment, we need |
278 | extra startup checks to avoid SEGV. */ |
279 | cmplt t4, t5, t8 # E : |
280 | beq t8, $u_head # U : |
281 | lda t2, -1 # E : mask out leading garbage in source |
282 | |
283 | mskqh t2, t5, t2 # U : |
284 | ornot t1, t2, t3 # E : (stall) |
285 | cmpbge zero, t3, t10 # E : is there a zero? (stall) |
286 | beq t10, $u_head # U : (stall) |
287 | |
288 | /* At this point we've found a zero in the first partial word of |
289 | the source. We need to isolate the valid source data and mask |
290 | it into the original destination data. (Incidentally, we know |
291 | that we'll need at least one byte of that original dest word.) */ |
292 | |
293 | ldq_u t0, 0(a0) # L : |
294 | negq t10, t6 # E : build bitmask of bytes <= zero |
295 | and t6, t10, t8 # E : (stall) |
296 | and a1, 7, t5 # E : |
297 | |
298 | subq t8, 1, t6 # E : |
299 | or t6, t8, t10 # E : (stall) |
300 | srl t8, t5, t8 # U : adjust final null return value |
301 | zapnot t2, t10, t2 # U : prepare source word; mirror changes (stall) |
302 | |
303 | and t1, t2, t1 # E : to source validity mask |
304 | extql t2, a1, t2 # U : |
305 | extql t1, a1, t1 # U : (stall) |
306 | andnot t0, t2, t0 # .. e1 : zero place for source to reside (stall) |
307 | |
308 | or t0, t1, t1 # e1 : and put it there |
309 | stq_u t1, 0(a0) # .. e0 : (stall) |
310 | ret (t9) # e1 : |
311 | |
312 | cfi_endproc |
313 | |