[PATCH] Move Kprobes and Oprofile to "Instrumentation Support" menu
[linux-2.6.git] / arch / ia64 / lib / memset.S
1 /* Optimized version of the standard memset() function.
2
3    Copyright (c) 2002 Hewlett-Packard Co/CERN
4         Sverre Jarp <Sverre.Jarp@cern.ch>
5
6    Return: dest
7
8    Inputs:
9         in0:    dest
10         in1:    value
11         in2:    count
12
13    The algorithm is fairly straightforward: set byte by byte until we
14    we get to a 16B-aligned address, then loop on 128 B chunks using an
15    early store as prefetching, then loop on 32B chucks, then clear remaining
16    words, finally clear remaining bytes.
17    Since a stf.spill f0 can store 16B in one go, we use this instruction
18    to get peak speed when value = 0.  */
19
20 #include <asm/asmmacro.h>
21 #undef ret
22
23 #define dest            in0
24 #define value           in1
25 #define cnt             in2
26
27 #define tmp             r31
28 #define save_lc         r30
29 #define ptr0            r29
30 #define ptr1            r28
31 #define ptr2            r27
32 #define ptr3            r26
33 #define ptr9            r24
34 #define loopcnt         r23
35 #define linecnt         r22
36 #define bytecnt         r21
37
38 #define fvalue          f6
39
40 // This routine uses only scratch predicate registers (p6 - p15)
41 #define p_scr           p6                      // default register for same-cycle branches
42 #define p_nz            p7
43 #define p_zr            p8
44 #define p_unalgn        p9
45 #define p_y             p11
46 #define p_n             p12
47 #define p_yy            p13
48 #define p_nn            p14
49
50 #define MIN1            15
51 #define MIN1P1HALF      8
52 #define LINE_SIZE       128
53 #define LSIZE_SH        7                       // shift amount
54 #define PREF_AHEAD      8
55
56 GLOBAL_ENTRY(memset)
57 { .mmi
58         .prologue
59         alloc   tmp = ar.pfs, 3, 0, 0, 0
60         lfetch.nt1 [dest]                       //
61         .save   ar.lc, save_lc
62         mov.i   save_lc = ar.lc
63         .body
64 } { .mmi
65         mov     ret0 = dest                     // return value
66         cmp.ne  p_nz, p_zr = value, r0          // use stf.spill if value is zero
67         cmp.eq  p_scr, p0 = cnt, r0
68 ;; }
69 { .mmi
70         and     ptr2 = -(MIN1+1), dest          // aligned address
71         and     tmp = MIN1, dest                // prepare to check for correct alignment
72         tbit.nz p_y, p_n = dest, 0              // Do we have an odd address? (M_B_U)
73 } { .mib
74         mov     ptr1 = dest
75         mux1    value = value, @brcst           // create 8 identical bytes in word
76 (p_scr) br.ret.dpnt.many rp                     // return immediately if count = 0
77 ;; }
78 { .mib
79         cmp.ne  p_unalgn, p0 = tmp, r0          //
80 } { .mib
81         sub     bytecnt = (MIN1+1), tmp         // NB: # of bytes to move is 1 higher than loopcnt
82         cmp.gt  p_scr, p0 = 16, cnt             // is it a minimalistic task?
83 (p_scr) br.cond.dptk.many .move_bytes_unaligned // go move just a few (M_B_U)
84 ;; }
85 { .mmi
86 (p_unalgn) add  ptr1 = (MIN1+1), ptr2           // after alignment
87 (p_unalgn) add  ptr2 = MIN1P1HALF, ptr2         // after alignment
88 (p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 3    // should we do a st8 ?
89 ;; }
90 { .mib
91 (p_y)   add     cnt = -8, cnt                   //
92 (p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 2  // should we do a st4 ?
93 } { .mib
94 (p_y)   st8     [ptr2] = value,-4               //
95 (p_n)   add     ptr2 = 4, ptr2                  //
96 ;; }
97 { .mib
98 (p_yy)  add     cnt = -4, cnt                   //
99 (p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 1    // should we do a st2 ?
100 } { .mib
101 (p_yy)  st4     [ptr2] = value,-2               //
102 (p_nn)  add     ptr2 = 2, ptr2                  //
103 ;; }
104 { .mmi
105         mov     tmp = LINE_SIZE+1               // for compare
106 (p_y)   add     cnt = -2, cnt                   //
107 (p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 0  // should we do a st1 ?
108 } { .mmi
109         setf.sig fvalue=value                   // transfer value to FLP side
110 (p_y)   st2     [ptr2] = value,-1               //
111 (p_n)   add     ptr2 = 1, ptr2                  //
112 ;; }
113
114 { .mmi
115 (p_yy)  st1     [ptr2] = value                  //
116         cmp.gt  p_scr, p0 = tmp, cnt            // is it a minimalistic task?
117 } { .mbb
118 (p_yy)  add     cnt = -1, cnt                   //
119 (p_scr) br.cond.dpnt.many .fraction_of_line     // go move just a few
120 ;; }
121
122 { .mib
123         nop.m 0
124         shr.u   linecnt = cnt, LSIZE_SH
125 (p_zr)  br.cond.dptk.many .l1b                  // Jump to use stf.spill
126 ;; }
127
128         TEXT_ALIGN(32) // --------------------- //  L1A: store ahead into cache lines; fill later
129 { .mmi
130         and     tmp = -(LINE_SIZE), cnt         // compute end of range
131         mov     ptr9 = ptr1                     // used for prefetching
132         and     cnt = (LINE_SIZE-1), cnt        // remainder
133 } { .mmi
134         mov     loopcnt = PREF_AHEAD-1          // default prefetch loop
135         cmp.gt  p_scr, p0 = PREF_AHEAD, linecnt // check against actual value
136 ;; }
137 { .mmi
138 (p_scr) add     loopcnt = -1, linecnt           //
139         add     ptr2 = 8, ptr1                  // start of stores (beyond prefetch stores)
140         add     ptr1 = tmp, ptr1                // first address beyond total range
141 ;; }
142 { .mmi
143         add     tmp = -1, linecnt               // next loop count
144         mov.i   ar.lc = loopcnt                 //
145 ;; }
146 .pref_l1a:
147 { .mib
148         stf8 [ptr9] = fvalue, 128               // Do stores one cache line apart
149         nop.i   0
150         br.cloop.dptk.few .pref_l1a
151 ;; }
152 { .mmi
153         add     ptr0 = 16, ptr2                 // Two stores in parallel
154         mov.i   ar.lc = tmp                     //
155 ;; }
156 .l1ax:
157  { .mmi
158         stf8 [ptr2] = fvalue, 8
159         stf8 [ptr0] = fvalue, 8
160  ;; }
161  { .mmi
162         stf8 [ptr2] = fvalue, 24
163         stf8 [ptr0] = fvalue, 24
164  ;; }
165  { .mmi
166         stf8 [ptr2] = fvalue, 8
167         stf8 [ptr0] = fvalue, 8
168  ;; }
169  { .mmi
170         stf8 [ptr2] = fvalue, 24
171         stf8 [ptr0] = fvalue, 24
172  ;; }
173  { .mmi
174         stf8 [ptr2] = fvalue, 8
175         stf8 [ptr0] = fvalue, 8
176  ;; }
177  { .mmi
178         stf8 [ptr2] = fvalue, 24
179         stf8 [ptr0] = fvalue, 24
180  ;; }
181  { .mmi
182         stf8 [ptr2] = fvalue, 8
183         stf8 [ptr0] = fvalue, 32
184         cmp.lt  p_scr, p0 = ptr9, ptr1          // do we need more prefetching?
185  ;; }
186 { .mmb
187         stf8 [ptr2] = fvalue, 24
188 (p_scr) stf8 [ptr9] = fvalue, 128
189         br.cloop.dptk.few .l1ax
190 ;; }
191 { .mbb
192         cmp.le  p_scr, p0 = 8, cnt              // just a few bytes left ?
193 (p_scr) br.cond.dpnt.many  .fraction_of_line    // Branch no. 2
194         br.cond.dpnt.many  .move_bytes_from_alignment   // Branch no. 3
195 ;; }
196
197         TEXT_ALIGN(32)
198 .l1b:   // ------------------------------------ //  L1B: store ahead into cache lines; fill later
199 { .mmi
200         and     tmp = -(LINE_SIZE), cnt         // compute end of range
201         mov     ptr9 = ptr1                     // used for prefetching
202         and     cnt = (LINE_SIZE-1), cnt        // remainder
203 } { .mmi
204         mov     loopcnt = PREF_AHEAD-1          // default prefetch loop
205         cmp.gt  p_scr, p0 = PREF_AHEAD, linecnt // check against actual value
206 ;; }
207 { .mmi
208 (p_scr) add     loopcnt = -1, linecnt
209         add     ptr2 = 16, ptr1                 // start of stores (beyond prefetch stores)
210         add     ptr1 = tmp, ptr1                // first address beyond total range
211 ;; }
212 { .mmi
213         add     tmp = -1, linecnt               // next loop count
214         mov.i   ar.lc = loopcnt
215 ;; }
216 .pref_l1b:
217 { .mib
218         stf.spill [ptr9] = f0, 128              // Do stores one cache line apart
219         nop.i   0
220         br.cloop.dptk.few .pref_l1b
221 ;; }
222 { .mmi
223         add     ptr0 = 16, ptr2                 // Two stores in parallel
224         mov.i   ar.lc = tmp
225 ;; }
226 .l1bx:
227  { .mmi
228         stf.spill [ptr2] = f0, 32
229         stf.spill [ptr0] = f0, 32
230  ;; }
231  { .mmi
232         stf.spill [ptr2] = f0, 32
233         stf.spill [ptr0] = f0, 32
234  ;; }
235  { .mmi
236         stf.spill [ptr2] = f0, 32
237         stf.spill [ptr0] = f0, 64
238         cmp.lt  p_scr, p0 = ptr9, ptr1          // do we need more prefetching?
239  ;; }
240 { .mmb
241         stf.spill [ptr2] = f0, 32
242 (p_scr) stf.spill [ptr9] = f0, 128
243         br.cloop.dptk.few .l1bx
244 ;; }
245 { .mib
246         cmp.gt  p_scr, p0 = 8, cnt              // just a few bytes left ?
247 (p_scr) br.cond.dpnt.many  .move_bytes_from_alignment   //
248 ;; }
249
250 .fraction_of_line:
251 { .mib
252         add     ptr2 = 16, ptr1
253         shr.u   loopcnt = cnt, 5                // loopcnt = cnt / 32
254 ;; }
255 { .mib
256         cmp.eq  p_scr, p0 = loopcnt, r0
257         add     loopcnt = -1, loopcnt
258 (p_scr) br.cond.dpnt.many .store_words
259 ;; }
260 { .mib
261         and     cnt = 0x1f, cnt                 // compute the remaining cnt
262         mov.i   ar.lc = loopcnt
263 ;; }
264         TEXT_ALIGN(32)
265 .l2:    // ------------------------------------ //  L2A:  store 32B in 2 cycles
266 { .mmb
267         stf8    [ptr1] = fvalue, 8
268         stf8    [ptr2] = fvalue, 8
269 ;; } { .mmb
270         stf8    [ptr1] = fvalue, 24
271         stf8    [ptr2] = fvalue, 24
272         br.cloop.dptk.many .l2
273 ;; }
274 .store_words:
275 { .mib
276         cmp.gt  p_scr, p0 = 8, cnt              // just a few bytes left ?
277 (p_scr) br.cond.dpnt.many .move_bytes_from_alignment    // Branch
278 ;; }
279
280 { .mmi
281         stf8    [ptr1] = fvalue, 8              // store
282         cmp.le  p_y, p_n = 16, cnt
283         add     cnt = -8, cnt                   // subtract
284 ;; }
285 { .mmi
286 (p_y)   stf8    [ptr1] = fvalue, 8              // store
287 (p_y)   cmp.le.unc p_yy, p_nn = 16, cnt
288 (p_y)   add     cnt = -8, cnt                   // subtract
289 ;; }
290 { .mmi                                          // store
291 (p_yy)  stf8    [ptr1] = fvalue, 8
292 (p_yy)  add     cnt = -8, cnt                   // subtract
293 ;; }
294
295 .move_bytes_from_alignment:
296 { .mib
297         cmp.eq  p_scr, p0 = cnt, r0
298         tbit.nz.unc p_y, p0 = cnt, 2            // should we terminate with a st4 ?
299 (p_scr) br.cond.dpnt.few .restore_and_exit
300 ;; }
301 { .mib
302 (p_y)   st4     [ptr1] = value,4
303         tbit.nz.unc p_yy, p0 = cnt, 1           // should we terminate with a st2 ?
304 ;; }
305 { .mib
306 (p_yy)  st2     [ptr1] = value,2
307         tbit.nz.unc p_y, p0 = cnt, 0            // should we terminate with a st1 ?
308 ;; }
309
310 { .mib
311 (p_y)   st1     [ptr1] = value
312 ;; }
313 .restore_and_exit:
314 { .mib
315         nop.m   0
316         mov.i   ar.lc = save_lc
317         br.ret.sptk.many rp
318 ;; }
319
320 .move_bytes_unaligned:
321 { .mmi
322        .pred.rel "mutex",p_y, p_n
323        .pred.rel "mutex",p_yy, p_nn
324 (p_n)   cmp.le  p_yy, p_nn = 4, cnt
325 (p_y)   cmp.le  p_yy, p_nn = 5, cnt
326 (p_n)   add     ptr2 = 2, ptr1
327 } { .mmi
328 (p_y)   add     ptr2 = 3, ptr1
329 (p_y)   st1     [ptr1] = value, 1               // fill 1 (odd-aligned) byte [15, 14 (or less) left]
330 (p_y)   add     cnt = -1, cnt
331 ;; }
332 { .mmi
333 (p_yy)  cmp.le.unc p_y, p0 = 8, cnt
334         add     ptr3 = ptr1, cnt                // prepare last store
335         mov.i   ar.lc = save_lc
336 } { .mmi
337 (p_yy)  st2     [ptr1] = value, 4               // fill 2 (aligned) bytes
338 (p_yy)  st2     [ptr2] = value, 4               // fill 2 (aligned) bytes [11, 10 (o less) left]
339 (p_yy)  add     cnt = -4, cnt
340 ;; }
341 { .mmi
342 (p_y)   cmp.le.unc p_yy, p0 = 8, cnt
343         add     ptr3 = -1, ptr3                 // last store
344         tbit.nz p_scr, p0 = cnt, 1              // will there be a st2 at the end ?
345 } { .mmi
346 (p_y)   st2     [ptr1] = value, 4               // fill 2 (aligned) bytes
347 (p_y)   st2     [ptr2] = value, 4               // fill 2 (aligned) bytes [7, 6 (or less) left]
348 (p_y)   add     cnt = -4, cnt
349 ;; }
350 { .mmi
351 (p_yy)  st2     [ptr1] = value, 4               // fill 2 (aligned) bytes
352 (p_yy)  st2     [ptr2] = value, 4               // fill 2 (aligned) bytes [3, 2 (or less) left]
353         tbit.nz p_y, p0 = cnt, 0                // will there be a st1 at the end ?
354 } { .mmi
355 (p_yy)  add     cnt = -4, cnt
356 ;; }
357 { .mmb
358 (p_scr) st2     [ptr1] = value                  // fill 2 (aligned) bytes
359 (p_y)   st1     [ptr3] = value                  // fill last byte (using ptr3)
360         br.ret.sptk.many rp
361 }
362 END(memset)