← Back to branch summary

~ubuntu-branches/ubuntu/utopic/linux-ti-omap/utopic

« back to all changes in this revision

Viewing changes to arch/alpha/lib/stxncpy.S

  • Committer: Bazaar Package Importer
  • Author(s): Amit Kucheria, Amit Kucheria
  • Date: 2010-03-10 02:28:15 UTC
  • Revision ID: james.westby@ubuntu.com-20100310022815-7sd3gwvn5kenaq33
Tags: 2.6.33-500.1
[ Amit Kucheria ]

* Initial release of a 2.6.33-based OMAP kernel
* UBUNTU: [Upstream] Fix omap 1-wire driver compilation
* UBUNTU: ubuntu: AppArmor -- update to mainline 2010-03-04

Show diffs side-by-side

added added

removed removed

Lines of Context:
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