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