xref: /openbmc/linux/arch/alpha/lib/stxncpy.S (revision bc5aa3a0) 
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
45stxncpy_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
1031:	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
2641:	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
2811:	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
3111:	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
346