1 | /* Optimized version of the memccpy() function. |
2 | This file is part of the GNU C Library. |
3 | Copyright (C) 2000-2022 Free Software Foundation, Inc. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | /* Return: a pointer to the next byte after char in dest or NULL |
20 | |
21 | Inputs: |
22 | in0: dest |
23 | in1: src |
24 | in2: char |
25 | in3: byte count |
26 | |
27 | This implementation assumes little endian mode (UM.be = 0). |
28 | |
29 | This implementation assumes that it is safe to do read ahead |
30 | in the src block, without getting beyond its limit. */ |
31 | |
32 | #include <sysdep.h> |
33 | #undef ret |
34 | |
35 | #define OP_T_THRES 16 |
36 | #define OPSIZ 8 |
37 | |
38 | #define saved_pr r17 |
39 | #define saved_lc r18 |
40 | #define dest r19 |
41 | #define src r20 |
42 | #define len r21 |
43 | #define asrc r22 |
44 | #define tmp r23 |
45 | #define char r24 |
46 | #define charx8 r25 |
47 | #define saved_ec r26 |
48 | #define sh2 r28 |
49 | #define sh1 r29 |
50 | #define loopcnt r30 |
51 | #define value r31 |
52 | |
53 | #ifdef GAS_ALIGN_BREAKS_UNWIND_INFO |
54 | /* Manually force proper loop-alignment. Note: be sure to |
55 | double-check the code-layout after making any changes to |
56 | this routine! */ |
57 | # define ALIGN(n) { nop 0 } |
58 | #else |
59 | # define ALIGN(n) .align n |
60 | #endif |
61 | |
62 | ENTRY(memccpy) |
63 | .prologue |
64 | alloc r2 = ar.pfs, 4, 40 - 4, 0, 40 |
65 | |
66 | #include "softpipe.h" |
67 | .rotr r[MEMLAT + 7], tmp1[4], tmp2[4], val[4], tmp3[2], pos0[2] |
68 | .rotp p[MEMLAT + 6 + 1] |
69 | |
70 | mov ret0 = r0 // return NULL if no match |
71 | .save pr, saved_pr |
72 | mov saved_pr = pr // save the predicate registers |
73 | mov dest = in0 // dest |
74 | .save ar.lc, saved_lc |
75 | mov saved_lc = ar.lc // save the loop counter |
76 | mov saved_ec = ar.ec // save the loop counter |
77 | .body |
78 | mov src = in1 // src |
79 | extr.u char = in2, 0, 8 // char |
80 | mov len = in3 // len |
81 | sub tmp = r0, in0 // tmp = -dest |
82 | cmp.ne p7, p0 = r0, r0 // clear p7 |
83 | ;; |
84 | and loopcnt = 7, tmp // loopcnt = -dest % 8 |
85 | cmp.ge p6, p0 = OP_T_THRES, len // is len <= OP_T_THRES |
86 | mov ar.ec = 0 // ec not guaranteed zero on entry |
87 | (p6) br.cond.spnt .cpyfew // copy byte by byte |
88 | ;; |
89 | cmp.eq p6, p0 = loopcnt, r0 |
90 | mux1 charx8 = char, @brcst |
91 | (p6) br.cond.sptk .dest_aligned |
92 | sub len = len, loopcnt // len -= -dest % 8 |
93 | adds loopcnt = -1, loopcnt // --loopcnt |
94 | ;; |
95 | mov ar.lc = loopcnt |
96 | .l1: // copy -dest % 8 bytes |
97 | ld1 value = [src], 1 // value = *src++ |
98 | ;; |
99 | st1 [dest] = value, 1 // *dest++ = value |
100 | cmp.eq p6, p0 = value, char |
101 | (p6) br.cond.spnt .foundit |
102 | br.cloop.dptk .l1 |
103 | .dest_aligned: |
104 | and sh1 = 7, src // sh1 = src % 8 |
105 | and tmp = -8, len // tmp = len & -OPSIZ |
106 | and asrc = -8, src // asrc = src & -OPSIZ -- align src |
107 | shr.u loopcnt = len, 3 // loopcnt = len / 8 |
108 | and len = 7, len ;; // len = len % 8 |
109 | shl sh1 = sh1, 3 // sh1 = 8 * (src % 8) |
110 | adds loopcnt = -1, loopcnt // --loopcnt |
111 | mov pr.rot = 1 << 16 ;; // set rotating predicates |
112 | sub sh2 = 64, sh1 // sh2 = 64 - sh1 |
113 | mov ar.lc = loopcnt // set LC |
114 | cmp.eq p6, p0 = sh1, r0 // is the src aligned? |
115 | (p6) br.cond.sptk .src_aligned ;; |
116 | add src = src, tmp // src += len & -OPSIZ |
117 | mov ar.ec = MEMLAT + 6 + 1 // six more passes needed |
118 | ld8 r[1] = [asrc], 8 // r[1] = w0 |
119 | cmp.ne p6, p0 = r0, r0 ;; // clear p6 |
120 | ALIGN(32) |
121 | .l2: |
122 | (p[0]) ld8.s r[0] = [asrc], 8 // r[0] = w1 |
123 | (p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 >> sh1 |
124 | (p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 // tmp2 = w1 << sh2 |
125 | (p[MEMLAT+4]) xor tmp3[0] = val[1], charx8 |
126 | (p[MEMLAT+5]) czx1.r pos0[0] = tmp3[1] |
127 | (p[MEMLAT+6]) chk.s r[6 + MEMLAT], .recovery1 // our data isn't |
128 | // valid - rollback! |
129 | (p[MEMLAT+6]) cmp.ne p6, p0 = 8, pos0[1] |
130 | (p6) br.cond.spnt .gotit |
131 | (p[MEMLAT+6]) st8 [dest] = val[3], 8 // store val to dest |
132 | (p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] // val = tmp1 | tmp2 |
133 | br.ctop.sptk .l2 |
134 | br.cond.sptk .cpyfew |
135 | |
136 | .src_aligned: |
137 | cmp.ne p6, p0 = r0, r0 // clear p6 |
138 | mov ar.ec = MEMLAT + 2 + 1 ;; // set EC |
139 | .l3: |
140 | (p[0]) ld8.s r[0] = [src], 8 |
141 | (p[MEMLAT]) xor tmp3[0] = r[MEMLAT], charx8 |
142 | (p[MEMLAT+1]) czx1.r pos0[0] = tmp3[1] |
143 | (p[MEMLAT+2]) cmp.ne p7, p0 = 8, pos0[1] |
144 | (p[MEMLAT+2]) chk.s r[MEMLAT+2], .recovery2 |
145 | (p7) br.cond.spnt .gotit |
146 | .back2: |
147 | (p[MEMLAT+2]) st8 [dest] = r[MEMLAT+2], 8 |
148 | br.ctop.dptk .l3 |
149 | .cpyfew: |
150 | cmp.eq p6, p0 = len, r0 // is len == 0 ? |
151 | adds len = -1, len // --len; |
152 | (p6) br.cond.spnt .restore_and_exit ;; |
153 | mov ar.lc = len |
154 | .l4: |
155 | ld1 value = [src], 1 |
156 | ;; |
157 | st1 [dest] = value, 1 |
158 | cmp.eq p6, p0 = value, char |
159 | (p6) br.cond.spnt .foundit |
160 | br.cloop.dptk .l4 ;; |
161 | .foundit: |
162 | (p6) mov ret0 = dest |
163 | .restore_and_exit: |
164 | mov pr = saved_pr, -1 // restore the predicate registers |
165 | mov ar.lc = saved_lc // restore the loop counter |
166 | mov ar.ec = saved_ec ;; // restore the epilog counter |
167 | br.ret.sptk.many b0 |
168 | .gotit: |
169 | .pred.rel "mutex" p6, p7 |
170 | (p6) mov value = val[3] // if coming from l2 |
171 | (p7) mov value = r[MEMLAT+2] // if coming from l3 |
172 | mov ar.lc = pos0[1] ;; |
173 | .l5: |
174 | extr.u tmp = value, 0, 8 ;; |
175 | st1 [dest] = tmp, 1 |
176 | shr.u value = value, 8 |
177 | br.cloop.sptk .l5 ;; |
178 | mov ret0 = dest |
179 | mov pr = saved_pr, -1 |
180 | mov ar.lc = saved_lc |
181 | br.ret.sptk.many b0 |
182 | |
183 | .recovery1: |
184 | #if MEMLAT != 6 |
185 | # error "MEMLAT must be 6!" |
186 | #endif |
187 | adds src = -8, asrc |
188 | mov loopcnt = ar.lc |
189 | mov tmp = ar.ec |
190 | ;; |
191 | (p[0]) adds src = -8, src |
192 | ;; |
193 | (p[1]) adds src = -8, src |
194 | sub sh1 = (MEMLAT + 6 + 1), tmp |
195 | ;; |
196 | (p[2]) adds src = -8, src |
197 | ;; |
198 | (p[3]) adds src = -8, src |
199 | shl loopcnt = loopcnt, 3 |
200 | ;; |
201 | (p[4]) adds src = -8, src |
202 | ;; |
203 | (p[5]) adds src = -8, src |
204 | shl sh1 = sh1, 3 |
205 | ;; |
206 | (p[6]) adds src = -8, src |
207 | ;; |
208 | (p[7]) adds src = -8, src |
209 | shl tmp = tmp, 3 |
210 | ;; |
211 | (p[8]) adds src = -8, src |
212 | ;; |
213 | (p[9]) adds src = -8, src |
214 | shr.u sh2 = sh2, 3 |
215 | ;; |
216 | (p[10]) adds src = -8, src |
217 | ;; |
218 | (p[11]) adds src = -8, src |
219 | add len = len, loopcnt |
220 | ;; |
221 | sub src = src, sh2 |
222 | ;; |
223 | add len = tmp, len |
224 | add src = sh1, src |
225 | br.cond.sptk .cpyfew |
226 | |
227 | .recovery2: |
228 | #if MEMLAT != 6 |
229 | # error "MEMLAT must be 6!" |
230 | #endif |
231 | add tmp = -8, src |
232 | (p7) br.cond.spnt .gotit |
233 | ;; |
234 | (p[0]) add tmp = -8, tmp ;; |
235 | (p[1]) add tmp = -8, tmp ;; |
236 | (p[2]) add tmp = -8, tmp ;; |
237 | (p[3]) add tmp = -8, tmp ;; |
238 | (p[4]) add tmp = -8, tmp ;; |
239 | (p[5]) add tmp = -8, tmp ;; |
240 | (p[6]) add tmp = -8, tmp ;; |
241 | (p[7]) add tmp = -8, tmp ;; |
242 | ld8 r[MEMLAT+2] = [tmp] ;; |
243 | xor pos0[1] = r[MEMLAT+2], charx8 ;; |
244 | czx1.r pos0[1] = pos0[1] ;; |
245 | cmp.ne p7, p6 = 8, pos0[1] |
246 | (p7) br.cond.spnt .gotit |
247 | br.cond.sptk .back2 |
248 | END(memccpy) |
249 | |