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