Linux-2.6.12-rc2
[linux-2.6.git] / arch / alpha / lib / ev6-stxncpy.S
1 /*
2  * arch/alpha/lib/ev6-stxncpy.S
3  * 21264 version contributed by Rick Gorton <rick.gorton@api-networks.com>
4  *
5  * Copy no more than COUNT bytes of the null-terminated string from
6  * SRC to DST.
7  *
8  * This is an internal routine used by strncpy, stpncpy, and strncat.
9  * As such, it uses special linkage conventions to make implementation
10  * of these public functions more efficient.
11  *
12  * On input:
13  *      t9 = return address
14  *      a0 = DST
15  *      a1 = SRC
16  *      a2 = COUNT
17  *
18  * Furthermore, COUNT may not be zero.
19  *
20  * On output:
21  *      t0  = last word written
22  *      t10 = bitmask (with one bit set) indicating the byte position of
23  *            the end of the range specified by COUNT
24  *      t12 = bitmask (with one bit set) indicating the last byte written
25  *      a0  = unaligned address of the last *word* written
26  *      a2  = the number of full words left in COUNT
27  *
28  * Furthermore, v0, a3-a5, t11, and $at are untouched.
29  *
30  * Much of the information about 21264 scheduling/coding comes from:
31  *      Compiler Writer's Guide for the Alpha 21264
32  *      abbreviated as 'CWG' in other comments here
33  *      ftp.digital.com/pub/Digital/info/semiconductor/literature/dsc-library.html
34  * Scheduling notation:
35  *      E       - either cluster
36  *      U       - upper subcluster; U0 - subcluster U0; U1 - subcluster U1
37  *      L       - lower subcluster; L0 - subcluster L0; L1 - subcluster L1
38  * Try not to change the actual algorithm if possible for consistency.
39  */
40
41 #include <asm/regdef.h>
42
43         .set noat
44         .set noreorder
45
46         .text
47
48 /* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
49    doesn't like putting the entry point for a procedure somewhere in the
50    middle of the procedure descriptor.  Work around this by putting the
51    aligned copy in its own procedure descriptor */
52
53
54         .ent stxncpy_aligned
55         .align 4
56 stxncpy_aligned:
57         .frame sp, 0, t9, 0
58         .prologue 0
59
60         /* On entry to this basic block:
61            t0 == the first destination word for masking back in
62            t1 == the first source word.  */
63
64         /* Create the 1st output word and detect 0's in the 1st input word.  */
65         lda     t2, -1          # E : build a mask against false zero
66         mskqh   t2, a1, t2      # U :   detection in the src word (stall)
67         mskqh   t1, a1, t3      # U :
68         ornot   t1, t2, t2      # E : (stall)
69
70         mskql   t0, a1, t0      # U : assemble the first output word
71         cmpbge  zero, t2, t8    # E : bits set iff null found
72         or      t0, t3, t0      # E : (stall)
73         beq     a2, $a_eoc      # U :
74
75         bne     t8, $a_eos      # U :
76         nop
77         nop
78         nop
79
80         /* On entry to this basic block:
81            t0 == a source word not containing a null.  */
82
83         /*
84          * nops here to:
85          *      separate store quads from load quads
86          *      limit of 1 bcond/quad to permit training
87          */
88 $a_loop:
89         stq_u   t0, 0(a0)       # L :
90         addq    a0, 8, a0       # E :
91         subq    a2, 1, a2       # E :
92         nop
93
94         ldq_u   t0, 0(a1)       # L :
95         addq    a1, 8, a1       # E :
96         cmpbge  zero, t0, t8    # E :
97         beq     a2, $a_eoc      # U :
98
99         beq     t8, $a_loop     # U :
100         nop
101         nop
102         nop
103
104         /* Take care of the final (partial) word store.  At this point
105            the end-of-count bit is set in t8 iff it applies.
106
107            On entry to this basic block we have:
108            t0 == the source word containing the null
109            t8 == the cmpbge mask that found it.  */
110
111 $a_eos:
112         negq    t8, t12         # E : find low bit set
113         and     t8, t12, t12    # E : (stall)
114         /* For the sake of the cache, don't read a destination word
115            if we're not going to need it.  */
116         and     t12, 0x80, t6   # E : (stall)
117         bne     t6, 1f          # U : (stall)
118
119         /* We're doing a partial word store and so need to combine
120            our source and original destination words.  */
121         ldq_u   t1, 0(a0)       # L :
122         subq    t12, 1, t6      # E :
123         or      t12, t6, t8     # E : (stall)
124         zapnot  t0, t8, t0      # U : clear src bytes > null (stall)
125
126         zap     t1, t8, t1      # .. e1 : clear dst bytes <= null
127         or      t0, t1, t0      # e1    : (stall)
128         nop
129         nop
130
131 1:      stq_u   t0, 0(a0)       # L :
132         ret     (t9)            # L0 : Latency=3
133         nop
134         nop
135
136         /* Add the end-of-count bit to the eos detection bitmask.  */
137 $a_eoc:
138         or      t10, t8, t8     # E :
139         br      $a_eos          # L0 : Latency=3
140         nop
141         nop
142
143         .end stxncpy_aligned
144
145         .align 4
146         .ent __stxncpy
147         .globl __stxncpy
148 __stxncpy:
149         .frame sp, 0, t9, 0
150         .prologue 0
151
152         /* Are source and destination co-aligned?  */
153         xor     a0, a1, t1      # E :
154         and     a0, 7, t0       # E : find dest misalignment
155         and     t1, 7, t1       # E : (stall)
156         addq    a2, t0, a2      # E : bias count by dest misalignment (stall)
157
158         subq    a2, 1, a2       # E :
159         and     a2, 7, t2       # E : (stall)
160         srl     a2, 3, a2       # U : a2 = loop counter = (count - 1)/8 (stall)
161         addq    zero, 1, t10    # E :
162
163         sll     t10, t2, t10    # U : t10 = bitmask of last count byte
164         bne     t1, $unaligned  # U :
165         /* We are co-aligned; take care of a partial first word.  */
166         ldq_u   t1, 0(a1)       # L : load first src word
167         addq    a1, 8, a1       # E :
168
169         beq     t0, stxncpy_aligned     # U : avoid loading dest word if not needed
170         ldq_u   t0, 0(a0)       # L :
171         nop
172         nop
173
174         br      stxncpy_aligned # .. e1 :
175         nop
176         nop
177         nop
178
179
180
181 /* The source and destination are not co-aligned.  Align the destination
182    and cope.  We have to be very careful about not reading too much and
183    causing a SEGV.  */
184
185         .align 4
186 $u_head:
187         /* We know just enough now to be able to assemble the first
188            full source word.  We can still find a zero at the end of it
189            that prevents us from outputting the whole thing.
190
191            On entry to this basic block:
192            t0 == the first dest word, unmasked
193            t1 == the shifted low bits of the first source word
194            t6 == bytemask that is -1 in dest word bytes */
195
196         ldq_u   t2, 8(a1)       # L : Latency=3 load second src word
197         addq    a1, 8, a1       # E :
198         mskql   t0, a0, t0      # U : mask trailing garbage in dst
199         extqh   t2, a1, t4      # U : (3 cycle stall on t2)
200
201         or      t1, t4, t1      # E : first aligned src word complete (stall)
202         mskqh   t1, a0, t1      # U : mask leading garbage in src (stall)
203         or      t0, t1, t0      # E : first output word complete (stall)
204         or      t0, t6, t6      # E : mask original data for zero test (stall)
205
206         cmpbge  zero, t6, t8    # E :
207         beq     a2, $u_eocfin   # U :
208         lda     t6, -1          # E :
209         nop
210
211         bne     t8, $u_final    # U :
212         mskql   t6, a1, t6      # U : mask out bits already seen
213         stq_u   t0, 0(a0)       # L : store first output word
214         or      t6, t2, t2      # E : (stall)
215
216         cmpbge  zero, t2, t8    # E : find nulls in second partial
217         addq    a0, 8, a0       # E :
218         subq    a2, 1, a2       # E :
219         bne     t8, $u_late_head_exit   # U :
220
221         /* Finally, we've got all the stupid leading edge cases taken care
222            of and we can set up to enter the main loop.  */
223         extql   t2, a1, t1      # U : position hi-bits of lo word
224         beq     a2, $u_eoc      # U :
225         ldq_u   t2, 8(a1)       # L : read next high-order source word
226         addq    a1, 8, a1       # E :
227
228         extqh   t2, a1, t0      # U : position lo-bits of hi word (stall)
229         cmpbge  zero, t2, t8    # E :
230         nop
231         bne     t8, $u_eos      # U :
232
233         /* Unaligned copy main loop.  In order to avoid reading too much,
234            the loop is structured to detect zeros in aligned source words.
235            This has, unfortunately, effectively pulled half of a loop
236            iteration out into the head and half into the tail, but it does
237            prevent nastiness from accumulating in the very thing we want
238            to run as fast as possible.
239
240            On entry to this basic block:
241            t0 == the shifted low-order bits from the current source word
242            t1 == the shifted high-order bits from the previous source word
243            t2 == the unshifted current source word
244
245            We further know that t2 does not contain a null terminator.  */
246
247         .align 4
248 $u_loop:
249         or      t0, t1, t0      # E : current dst word now complete
250         subq    a2, 1, a2       # E : decrement word count
251         extql   t2, a1, t1      # U : extract low bits for next time
252         addq    a0, 8, a0       # E :
253
254         stq_u   t0, -8(a0)      # U : save the current word
255         beq     a2, $u_eoc      # U :
256         ldq_u   t2, 8(a1)       # U : Latency=3 load high word for next time
257         addq    a1, 8, a1       # E :
258
259         extqh   t2, a1, t0      # U : extract low bits (2 cycle stall)
260         cmpbge  zero, t2, t8    # E : test new word for eos
261         nop
262         beq     t8, $u_loop     # U :
263
264         /* We've found a zero somewhere in the source word we just read.
265            If it resides in the lower half, we have one (probably partial)
266            word to write out, and if it resides in the upper half, we
267            have one full and one partial word left to write out.
268
269            On entry to this basic block:
270            t0 == the shifted low-order bits from the current source word
271            t1 == the shifted high-order bits from the previous source word
272            t2 == the unshifted current source word.  */
273 $u_eos:
274         or      t0, t1, t0      # E : first (partial) source word complete
275         nop
276         cmpbge  zero, t0, t8    # E : is the null in this first bit? (stall)
277         bne     t8, $u_final    # U : (stall)
278
279         stq_u   t0, 0(a0)       # L : the null was in the high-order bits
280         addq    a0, 8, a0       # E :
281         subq    a2, 1, a2       # E :
282         nop
283
284 $u_late_head_exit:
285         extql   t2, a1, t0      # U :
286         cmpbge  zero, t0, t8    # E :
287         or      t8, t10, t6     # E : (stall)
288         cmoveq  a2, t6, t8      # E : Latency=2, extra map slot (stall)
289
290         /* Take care of a final (probably partial) result word.
291            On entry to this basic block:
292            t0 == assembled source word
293            t8 == cmpbge mask that found the null.  */
294 $u_final:
295         negq    t8, t6          # E : isolate low bit set
296         and     t6, t8, t12     # E : (stall)
297         and     t12, 0x80, t6   # E : avoid dest word load if we can (stall)
298         bne     t6, 1f          # U : (stall)
299
300         ldq_u   t1, 0(a0)       # L :
301         subq    t12, 1, t6      # E :
302         or      t6, t12, t8     # E : (stall)
303         zapnot  t0, t8, t0      # U : kill source bytes > null
304
305         zap     t1, t8, t1      # U : kill dest bytes <= null
306         or      t0, t1, t0      # E : (stall)
307         nop
308         nop
309
310 1:      stq_u   t0, 0(a0)       # L :
311         ret     (t9)            # L0 : Latency=3
312
313           /* Got to end-of-count before end of string.  
314              On entry to this basic block:
315              t1 == the shifted high-order bits from the previous source word  */
316 $u_eoc:
317         and     a1, 7, t6       # E : avoid final load if possible
318         sll     t10, t6, t6     # U : (stall)
319         and     t6, 0xff, t6    # E : (stall)
320         bne     t6, 1f          # U : (stall)
321
322         ldq_u   t2, 8(a1)       # L : load final src word
323         nop
324         extqh   t2, a1, t0      # U : extract low bits for last word (stall)
325         or      t1, t0, t1      # E : (stall)
326
327 1:      cmpbge  zero, t1, t8    # E :
328         mov     t1, t0          # E :
329
330 $u_eocfin:                      # end-of-count, final word
331         or      t10, t8, t8     # E :
332         br      $u_final        # L0 : Latency=3
333
334         /* Unaligned copy entry point.  */
335         .align 4
336 $unaligned:
337
338         ldq_u   t1, 0(a1)       # L : load first source word
339         and     a0, 7, t4       # E : find dest misalignment
340         and     a1, 7, t5       # E : find src misalignment
341         /* Conditionally load the first destination word and a bytemask
342            with 0xff indicating that the destination byte is sacrosanct.  */
343         mov     zero, t0        # E :
344
345         mov     zero, t6        # E :
346         beq     t4, 1f          # U :
347         ldq_u   t0, 0(a0)       # L :
348         lda     t6, -1          # E :
349
350         mskql   t6, a0, t6      # U :
351         nop
352         nop
353         subq    a1, t4, a1      # E : sub dest misalignment from src addr
354
355         /* If source misalignment is larger than dest misalignment, we need
356            extra startup checks to avoid SEGV.  */
357
358 1:      cmplt   t4, t5, t12     # E :
359         extql   t1, a1, t1      # U : shift src into place
360         lda     t2, -1          # E : for creating masks later
361         beq     t12, $u_head    # U : (stall)
362
363         extql   t2, a1, t2      # U :
364         cmpbge  zero, t1, t8    # E : is there a zero?
365         andnot  t2, t6, t12     # E : dest mask for a single word copy
366         or      t8, t10, t5     # E : test for end-of-count too
367
368         cmpbge  zero, t12, t3   # E :
369         cmoveq  a2, t5, t8      # E : Latency=2, extra map slot
370         nop                     # E : keep with cmoveq
371         andnot  t8, t3, t8      # E : (stall)
372
373         beq     t8, $u_head     # U :
374         /* At this point we've found a zero in the first partial word of
375            the source.  We need to isolate the valid source data and mask
376            it into the original destination data.  (Incidentally, we know
377            that we'll need at least one byte of that original dest word.) */
378         ldq_u   t0, 0(a0)       # L :
379         negq    t8, t6          # E : build bitmask of bytes <= zero
380         mskqh   t1, t4, t1      # U :
381
382         and     t6, t8, t2      # E :
383         subq    t2, 1, t6       # E : (stall)
384         or      t6, t2, t8      # E : (stall)
385         zapnot  t12, t8, t12    # U : prepare source word; mirror changes (stall)
386
387         zapnot  t1, t8, t1      # U : to source validity mask
388         andnot  t0, t12, t0     # E : zero place for source to reside
389         or      t0, t1, t0      # E : and put it there (stall both t0, t1)
390         stq_u   t0, 0(a0)       # L : (stall)
391
392         ret     (t9)            # L0 : Latency=3
393         nop
394         nop
395         nop
396
397         .end __stxncpy