Delete all instances of asm/system.h
[linux-2.6.git] / arch / alpha / lib / stxncpy.S
1 /*
2  * arch/alpha/lib/stxncpy.S
3  * Contributed by Richard Henderson (rth@tamu.edu)
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
31 #include <asm/regdef.h>
32
33         .set noat
34         .set noreorder
35
36         .text
37
38 /* There is a problem with either gdb (as of 4.16) or gas (as of 2.7) that
39    doesn't like putting the entry point for a procedure somewhere in the
40    middle of the procedure descriptor.  Work around this by putting the
41    aligned copy in its own procedure descriptor */
42
43         .ent stxncpy_aligned
44         .align 3
45 stxncpy_aligned:
46         .frame sp, 0, t9, 0
47         .prologue 0
48
49         /* On entry to this basic block:
50            t0 == the first destination word for masking back in
51            t1 == the first source word.  */
52
53         /* Create the 1st output word and detect 0's in the 1st input word.  */
54         lda     t2, -1          # e1    : build a mask against false zero
55         mskqh   t2, a1, t2      # e0    :   detection in the src word
56         mskqh   t1, a1, t3      # e0    :
57         ornot   t1, t2, t2      # .. e1 :
58         mskql   t0, a1, t0      # e0    : assemble the first output word
59         cmpbge  zero, t2, t8    # .. e1 : bits set iff null found
60         or      t0, t3, t0      # e0    :
61         beq     a2, $a_eoc      # .. e1 :
62         bne     t8, $a_eos      # .. e1 :
63
64         /* On entry to this basic block:
65            t0 == a source word not containing a null.  */
66
67 $a_loop:
68         stq_u   t0, 0(a0)       # e0    :
69         addq    a0, 8, a0       # .. e1 :
70         ldq_u   t0, 0(a1)       # e0    :
71         addq    a1, 8, a1       # .. e1 :
72         subq    a2, 1, a2       # e0    :
73         cmpbge  zero, t0, t8    # .. e1 (stall)
74         beq     a2, $a_eoc      # e1    :
75         beq     t8, $a_loop     # e1    :
76
77         /* Take care of the final (partial) word store.  At this point
78            the end-of-count bit is set in t8 iff it applies.
79
80            On entry to this basic block we have:
81            t0 == the source word containing the null
82            t8 == the cmpbge mask that found it.  */
83
84 $a_eos:
85         negq    t8, t12         # e0    : find low bit set
86         and     t8, t12, t12    # e1 (stall)
87
88         /* For the sake of the cache, don't read a destination word
89            if we're not going to need it.  */
90         and     t12, 0x80, t6   # e0    :
91         bne     t6, 1f          # .. e1 (zdb)
92
93         /* We're doing a partial word store and so need to combine
94            our source and original destination words.  */
95         ldq_u   t1, 0(a0)       # e0    :
96         subq    t12, 1, t6      # .. e1 :
97         or      t12, t6, t8     # e0    :
98         unop                    #
99         zapnot  t0, t8, t0      # e0    : clear src bytes > null
100         zap     t1, t8, t1      # .. e1 : clear dst bytes <= null
101         or      t0, t1, t0      # e1    :
102
103 1:      stq_u   t0, 0(a0)       # e0    :
104         ret     (t9)            # e1    :
105
106         /* Add the end-of-count bit to the eos detection bitmask.  */
107 $a_eoc:
108         or      t10, t8, t8
109         br      $a_eos
110
111         .end stxncpy_aligned
112
113         .align 3
114         .ent __stxncpy
115         .globl __stxncpy
116 __stxncpy:
117         .frame sp, 0, t9, 0
118         .prologue 0
119
120         /* Are source and destination co-aligned?  */
121         xor     a0, a1, t1      # e0    :
122         and     a0, 7, t0       # .. e1 : find dest misalignment
123         and     t1, 7, t1       # e0    :
124         addq    a2, t0, a2      # .. e1 : bias count by dest misalignment
125         subq    a2, 1, a2       # e0    :
126         and     a2, 7, t2       # e1    :
127         srl     a2, 3, a2       # e0    : a2 = loop counter = (count - 1)/8
128         addq    zero, 1, t10    # .. e1 :
129         sll     t10, t2, t10    # e0    : t10 = bitmask of last count byte
130         bne     t1, $unaligned  # .. e1 :
131
132         /* We are co-aligned; take care of a partial first word.  */
133
134         ldq_u   t1, 0(a1)       # e0    : load first src word
135         addq    a1, 8, a1       # .. e1 :
136
137         beq     t0, stxncpy_aligned     # avoid loading dest word if not needed
138         ldq_u   t0, 0(a0)       # e0    :
139         br      stxncpy_aligned # .. e1 :
140
141
142 /* The source and destination are not co-aligned.  Align the destination
143    and cope.  We have to be very careful about not reading too much and
144    causing a SEGV.  */
145
146         .align 3
147 $u_head:
148         /* We know just enough now to be able to assemble the first
149            full source word.  We can still find a zero at the end of it
150            that prevents us from outputting the whole thing.
151
152            On entry to this basic block:
153            t0 == the first dest word, unmasked
154            t1 == the shifted low bits of the first source word
155            t6 == bytemask that is -1 in dest word bytes */
156
157         ldq_u   t2, 8(a1)       # e0    : load second src word
158         addq    a1, 8, a1       # .. e1 :
159         mskql   t0, a0, t0      # e0    : mask trailing garbage in dst
160         extqh   t2, a1, t4      # e0    :
161         or      t1, t4, t1      # e1    : first aligned src word complete
162         mskqh   t1, a0, t1      # e0    : mask leading garbage in src
163         or      t0, t1, t0      # e0    : first output word complete
164         or      t0, t6, t6      # e1    : mask original data for zero test
165         cmpbge  zero, t6, t8    # e0    :
166         beq     a2, $u_eocfin   # .. e1 :
167         lda     t6, -1          # e0    :
168         bne     t8, $u_final    # .. e1 :
169
170         mskql   t6, a1, t6      # e0    : mask out bits already seen
171         nop                     # .. e1 :
172         stq_u   t0, 0(a0)       # e0    : store first output word
173         or      t6, t2, t2      # .. e1 :
174         cmpbge  zero, t2, t8    # e0    : find nulls in second partial
175         addq    a0, 8, a0       # .. e1 :
176         subq    a2, 1, a2       # e0    :
177         bne     t8, $u_late_head_exit   # .. e1 :
178
179         /* Finally, we've got all the stupid leading edge cases taken care
180            of and we can set up to enter the main loop.  */
181
182         extql   t2, a1, t1      # e0    : position hi-bits of lo word
183         beq     a2, $u_eoc      # .. e1 :
184         ldq_u   t2, 8(a1)       # e0    : read next high-order source word
185         addq    a1, 8, a1       # .. e1 :
186         extqh   t2, a1, t0      # e0    : position lo-bits of hi word (stall)
187         cmpbge  zero, t2, t8    # .. e1 :
188         nop                     # e0    :
189         bne     t8, $u_eos      # .. e1 :
190
191         /* Unaligned copy main loop.  In order to avoid reading too much,
192            the loop is structured to detect zeros in aligned source words.
193            This has, unfortunately, effectively pulled half of a loop
194            iteration out into the head and half into the tail, but it does
195            prevent nastiness from accumulating in the very thing we want
196            to run as fast as possible.
197
198            On entry to this basic block:
199            t0 == the shifted low-order bits from the current source word
200            t1 == the shifted high-order bits from the previous source word
201            t2 == the unshifted current source word
202
203            We further know that t2 does not contain a null terminator.  */
204
205         .align 3
206 $u_loop:
207         or      t0, t1, t0      # e0    : current dst word now complete
208         subq    a2, 1, a2       # .. e1 : decrement word count
209         stq_u   t0, 0(a0)       # e0    : save the current word
210         addq    a0, 8, a0       # .. e1 :
211         extql   t2, a1, t1      # e0    : extract high bits for next time
212         beq     a2, $u_eoc      # .. e1 :
213         ldq_u   t2, 8(a1)       # e0    : load high word for next time
214         addq    a1, 8, a1       # .. e1 :
215         nop                     # e0    :
216         cmpbge  zero, t2, t8    # e1    : test new word for eos (stall)
217         extqh   t2, a1, t0      # e0    : extract low bits for current word
218         beq     t8, $u_loop     # .. e1 :
219
220         /* We've found a zero somewhere in the source word we just read.
221            If it resides in the lower half, we have one (probably partial)
222            word to write out, and if it resides in the upper half, we
223            have one full and one partial word left to write out.
224
225            On entry to this basic block:
226            t0 == the shifted low-order bits from the current source word
227            t1 == the shifted high-order bits from the previous source word
228            t2 == the unshifted current source word.  */
229 $u_eos:
230         or      t0, t1, t0      # e0    : first (partial) source word complete
231         nop                     # .. e1 :
232         cmpbge  zero, t0, t8    # e0    : is the null in this first bit?
233         bne     t8, $u_final    # .. e1 (zdb)
234
235         stq_u   t0, 0(a0)       # e0    : the null was in the high-order bits
236         addq    a0, 8, a0       # .. e1 :
237         subq    a2, 1, a2       # e1    :
238
239 $u_late_head_exit:
240         extql   t2, a1, t0      # .. e0 :
241         cmpbge  zero, t0, t8    # e0    :
242         or      t8, t10, t6     # e1    :
243         cmoveq  a2, t6, t8      # e0    :
244         nop                     # .. e1 :
245
246         /* Take care of a final (probably partial) result word.
247            On entry to this basic block:
248            t0 == assembled source word
249            t8 == cmpbge mask that found the null.  */
250 $u_final:
251         negq    t8, t6          # e0    : isolate low bit set
252         and     t6, t8, t12     # e1    :
253
254         and     t12, 0x80, t6   # e0    : avoid dest word load if we can
255         bne     t6, 1f          # .. e1 (zdb)
256
257         ldq_u   t1, 0(a0)       # e0    :
258         subq    t12, 1, t6      # .. e1 :
259         or      t6, t12, t8     # e0    :
260         zapnot  t0, t8, t0      # .. e1 : kill source bytes > null
261         zap     t1, t8, t1      # e0    : kill dest bytes <= null
262         or      t0, t1, t0      # e1    :
263
264 1:      stq_u   t0, 0(a0)       # e0    :
265         ret     (t9)            # .. e1 :
266
267         /* Got to end-of-count before end of string.  
268            On entry to this basic block:
269            t1 == the shifted high-order bits from the previous source word  */
270 $u_eoc:
271         and     a1, 7, t6       # e1    :
272         sll     t10, t6, t6     # e0    :
273         and     t6, 0xff, t6    # e0    :
274         bne     t6, 1f          # .. e1 :
275
276         ldq_u   t2, 8(a1)       # e0    : load final src word
277         nop                     # .. e1 :
278         extqh   t2, a1, t0      # e0    : extract low bits for last word
279         or      t1, t0, t1      # e1    :
280
281 1:      cmpbge  zero, t1, t8
282         mov     t1, t0
283
284 $u_eocfin:                      # end-of-count, final word
285         or      t10, t8, t8
286         br      $u_final
287
288         /* Unaligned copy entry point.  */
289         .align 3
290 $unaligned:
291
292         ldq_u   t1, 0(a1)       # e0    : load first source word
293
294         and     a0, 7, t4       # .. e1 : find dest misalignment
295         and     a1, 7, t5       # e0    : find src misalignment
296
297         /* Conditionally load the first destination word and a bytemask
298            with 0xff indicating that the destination byte is sacrosanct.  */
299
300         mov     zero, t0        # .. e1 :
301         mov     zero, t6        # e0    :
302         beq     t4, 1f          # .. e1 :
303         ldq_u   t0, 0(a0)       # e0    :
304         lda     t6, -1          # .. e1 :
305         mskql   t6, a0, t6      # e0    :
306         subq    a1, t4, a1      # .. e1 : sub dest misalignment from src addr
307
308         /* If source misalignment is larger than dest misalignment, we need
309            extra startup checks to avoid SEGV.  */
310
311 1:      cmplt   t4, t5, t12     # e1    :
312         extql   t1, a1, t1      # .. e0 : shift src into place
313         lda     t2, -1          # e0    : for creating masks later
314         beq     t12, $u_head    # .. e1 :
315
316         extql   t2, a1, t2      # e0    :
317         cmpbge  zero, t1, t8    # .. e1 : is there a zero?
318         andnot  t2, t6, t2      # e0    : dest mask for a single word copy
319         or      t8, t10, t5     # .. e1 : test for end-of-count too
320         cmpbge  zero, t2, t3    # e0    :
321         cmoveq  a2, t5, t8      # .. e1 :
322         andnot  t8, t3, t8      # e0    :
323         beq     t8, $u_head     # .. e1 (zdb)
324
325         /* At this point we've found a zero in the first partial word of
326            the source.  We need to isolate the valid source data and mask
327            it into the original destination data.  (Incidentally, we know
328            that we'll need at least one byte of that original dest word.) */
329
330         ldq_u   t0, 0(a0)       # e0    :
331         negq    t8, t6          # .. e1 : build bitmask of bytes <= zero
332         mskqh   t1, t4, t1      # e0    :
333         and     t6, t8, t12     # .. e1 :
334         subq    t12, 1, t6      # e0    :
335         or      t6, t12, t8     # e1    :
336
337         zapnot  t2, t8, t2      # e0    : prepare source word; mirror changes
338         zapnot  t1, t8, t1      # .. e1 : to source validity mask
339
340         andnot  t0, t2, t0      # e0    : zero place for source to reside
341         or      t0, t1, t0      # e1    : and put it there
342         stq_u   t0, 0(a0)       # e0    :
343         ret     (t9)            # .. e1 :
344
345         .end __stxncpy