| blob | 7ffe9b9f38556cc35daac15ef519be3914677d52 |
1 /* Optimized version of the memccpy() function.
2 This file is part of the GNU C Library.
3 Copyright (C) 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Dan Pop <Dan.Pop@cern.ch>.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
21 /* Return: a pointer to the next byte after char in dest or NULL
23 Inputs:
24 in0: dest
25 in1: src
26 in2: char
27 in3: byte count
29 This implementation assumes little endian mode (UM.be = 0).
31 This implementation assumes that it is safe to do read ahead
32 in the src block, without getting beyond its limit. */
34 #include <sysdep.h>
35 #undef ret
37 #define OP_T_THRES 16
38 #define OPSIZ 8
40 #define saved_pr r17
41 #define saved_lc r18
42 #define dest r19
43 #define src r20
44 #define len r21
45 #define asrc r22
46 #define tmp r23
47 #define char r24
48 #define charx8 r25
49 #define sh2 r28
50 #define sh1 r29
51 #define loopcnt r30
52 #define value r31
54 ENTRY(memccpy)
55 .prologue
56 alloc r2 = ar.pfs, 4, 40 - 4, 0, 40
58 #include "softpipe.h"
59 .rotr r[MEMLAT + 3], tmp1[4], tmp2[4], val[4], tmp3[2], pos0[2]
60 .rotp p[MEMLAT + 6 + 1]
62 mov ret0 = r0 // return NULL if no match
63 .save pr, saved_pr
64 mov saved_pr = pr // save the predicate registers
65 .save ar.lc, saved_lc
66 mov saved_lc = ar.lc // save the loop counter
67 .body
68 mov dest = in0 // dest
69 mov src = in1 // src
70 extr.u char = in2, 0, 8 // char
71 mov len = in3 // len
72 sub tmp = r0, in0 // tmp = -dest
73 cmp.ne p7, p0 = r0, r0 // clear p7
74 ;;
75 and loopcnt = 7, tmp // loopcnt = -dest % 8
76 cmp.ge p6, p0 = OP_T_THRES, len // is len <= OP_T_THRES
77 (p6) br.cond.spnt .cpyfew // copy byte by byte
78 ;;
79 cmp.eq p6, p0 = loopcnt, r0
80 mux1 charx8 = char, @brcst
81 (p6) br.cond.sptk .dest_aligned
82 sub len = len, loopcnt // len -= -dest % 8
83 adds loopcnt = -1, loopcnt // --loopcnt
84 ;;
85 mov ar.lc = loopcnt
86 .l1: // copy -dest % 8 bytes
87 ld1 value = [src], 1 // value = *src++
88 ;;
89 st1 [dest] = value, 1 // *dest++ = value
90 cmp.eq p6, p0 = value, char
91 (p6) br.cond.spnt .foundit
92 br.cloop.dptk .l1
93 .dest_aligned:
94 and sh1 = 7, src // sh1 = src % 8
95 and tmp = -8, len // tmp = len & -OPSIZ
96 and asrc = -8, src // asrc = src & -OPSIZ -- align src
97 shr.u loopcnt = len, 3 // loopcnt = len / 8
98 and len = 7, len ;; // len = len % 8
99 shl sh1 = sh1, 3 // sh1 = 8 * (src % 8)
100 adds loopcnt = -1, loopcnt // --loopcnt
101 mov pr.rot = 1 << 16 ;; // set rotating predicates
102 sub sh2 = 64, sh1 // sh2 = 64 - sh1
103 mov ar.lc = loopcnt // set LC
104 cmp.eq p6, p0 = sh1, r0 // is the src aligned?
105 (p6) br.cond.sptk .src_aligned ;;
106 add src = src, tmp // src += len & -OPSIZ
107 mov ar.ec = MEMLAT + 6 + 1 // six more passes needed
108 ld8 r[1] = [asrc], 8 // r[1] = w0
109 cmp.ne p6, p0 = r0, r0 ;; // clear p6
110 .align 32
111 .l2:
112 (p[0]) ld8 r[0] = [asrc], 8 // r[0] = w1
113 (p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 >> sh1
114 (p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 // tmp2 = w1 << sh2
115 (p[MEMLAT+4]) xor tmp3[0] = val[1], charx8
116 (p[MEMLAT+5]) czx1.r pos0[0] = tmp3[1]
117 (p[MEMLAT+6]) cmp.ne p6, p0 = 8, pos0[1]
118 (p6) br.cond.spnt .gotit
119 (p[MEMLAT+6]) st8 [dest] = val[3], 8 // store val to dest
120 (p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] // val = tmp1 | tmp2
121 br.ctop.sptk .l2
122 br.cond.sptk .cpyfew
123 .src_aligned:
124 cmp.ne p6, p0 = r0, r0 // clear p6
125 mov ar.ec = MEMLAT + 2 + 1 ;; // set EC
126 .l3:
127 (p[0]) ld8 r[0] = [src], 8
128 (p[MEMLAT]) xor tmp3[0] = r[MEMLAT], charx8
129 (p[MEMLAT+1]) czx1.r pos0[0] = tmp3[1]
130 (p[MEMLAT+2]) cmp.ne p7, p0 = 8, pos0[1]
131 (p7) br.cond.spnt .gotit
132 (p[MEMLAT+2]) st8 [dest] = r[MEMLAT+2], 8
133 br.ctop.dptk .l3
134 .cpyfew:
135 cmp.eq p6, p0 = len, r0 // is len == 0 ?
136 adds len = -1, len // --len;
137 (p6) br.cond.spnt .restore_and_exit ;;
138 mov ar.lc = len
139 .l4:
140 ld1 value = [src], 1
141 ;;
142 st1 [dest] = value, 1
143 cmp.eq p6, p0 = value, char
144 (p6) br.cond.spnt .foundit
145 br.cloop.dptk .l4 ;;
146 .foundit:
147 (p6) mov ret0 = dest
148 .restore_and_exit:
149 mov pr = saved_pr, -1 // restore the predicate registers
150 mov ar.lc = saved_lc // restore the loop counter
151 br.ret.sptk.many b0
152 .gotit:
153 .pred.rel "mutex" p6, p7
154 (p6) mov value = val[3] // if coming from l2
155 (p7) mov value = r[MEMLAT+2] // if coming from l3
156 mov ar.lc = pos0[1] ;;
157 .l5:
158 extr.u tmp = value, 0, 8 ;;
159 st1 [dest] = tmp, 1
160 shr.u value = value, 8
161 br.cloop.sptk .l5 ;;
162 mov ret0 = dest
163 mov pr = saved_pr, -1
164 mov ar.lc = saved_lc
165 br.ret.sptk.many b0
166 END(memccpy)