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