OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [newlib/] [newlib/] [libc/] [machine/] [i960/] [strncat_ca.S] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 39 lampret
/*******************************************************************************
2
 *
3
 * Copyright (c) 1993 Intel Corporation
4
 *
5
 * Intel hereby grants you permission to copy, modify, and distribute this
6
 * software and its documentation.  Intel grants this permission provided
7
 * that the above copyright notice appears in all copies and that both the
8
 * copyright notice and this permission notice appear in supporting
9
 * documentation.  In addition, Intel grants this permission provided that
10
 * you prominently mark as "not part of the original" any modifications
11
 * made to this software or documentation, and that the name of Intel
12
 * Corporation not be used in advertising or publicity pertaining to
13
 * distribution of the software or the documentation without specific,
14
 * written prior permission.
15
 *
16
 * Intel Corporation provides this AS IS, WITHOUT ANY WARRANTY, EXPRESS OR
17
 * IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY
18
 * OR FITNESS FOR A PARTICULAR PURPOSE.  Intel makes no guarantee or
19
 * representations regarding the use of, or the results of the use of,
20
 * the software and documentation in terms of correctness, accuracy,
21
 * reliability, currentness, or otherwise; and you rely on the software,
22
 * documentation and results solely at your own risk.
23
 *
24
 * IN NO EVENT SHALL INTEL BE LIABLE FOR ANY LOSS OF USE, LOSS OF BUSINESS,
25
 * LOSS OF PROFITS, INDIRECT, INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES
26
 * OF ANY KIND.  IN NO EVENT SHALL INTEL'S TOTAL LIABILITY EXCEED THE SUM
27
 * PAID TO INTEL FOR THE PRODUCT LICENSED HEREUNDER.
28
 *
29
 ******************************************************************************/
30
 
31
        .file "sncat_ca.s"
32
#ifdef  __PIC
33
        .pic
34
#endif
35
#ifdef  __PID
36
        .pid
37
#endif
38
/*
39
 * (c) copyright 1988,1993 Intel Corp., all rights reserved
40
 */
41
 
42
/*
43
        procedure strncat  (optimized assembler version for the CA)
44
 
45
        dest_addr = strncat (dest_addr, src_addr, max_bytes)
46
 
47
        append the null terminated string pointed to by src_addr to the null
48
        terminated string pointed to by dest_addr.  Return the original
49
        dest_addr.  If the source string is longer than max_bytes, then
50
        append only max_bytes bytes, and tack on a null byte on the end
51
 
52
        This routine will fail if the source and destination string
53
        overlap (in particular, if the end of the source is overlapped
54
        by the beginning of the destination).  The behavior is undefined.
55
        This is acceptable according to the draft C standard.
56
 
57
        Undefined behavior will also occur if the end of the source string
58
        (i.e. the terminating null byte) is in the last word of the program's
59
        allocated memory space.  This is so because, in several cases, strncat
60
        will fetch ahead one word.  Disallowing the fetch ahead would impose
61
        a severe performance penalty.
62
 
63
        This program handles five cases:
64
 
65
        1) both arguments start on a word boundary
66
        2) neither are word aligned, but they are offset by the same amount
67
        3) source is word aligned, destination is not
68
        4) destination is word aligned, source is not
69
        5) neither is word aligned, and they are offset by differing amounts
70
 
71
        At the time of this writing, only g0 thru g7 and g13 are available
72
        for use in this leafproc;  other registers would have to be saved and
73
        restored.  These nine registers, plus tricky use of g14 are sufficient
74
        to implement the routine.  The registers are used as follows:
75
 
76
        g0  original dest ptr;  not modified, so that it may be returned.
77
        g1  src ptr;  shift count
78
        g2  max_bytes
79
        g3  src ptr (word aligned)
80
        g4  dest ptr (word aligned)
81
        g5  0xff  --  byte extraction mask
82
        Little endian:
83
                g6  lsw of double word for extraction of 4 bytes
84
                g7  msw of double word for extraction of 4 bytes
85
        Big endian:
86
                g6  msw of double word for extraction of 4 bytes
87
                g7  lsw of double word for extraction of 4 bytes
88
        g13 return address
89
        g14 byte extracted.
90
*/
91
 
92
#if __i960_BIG_ENDIAN__
93
#define MSW g6
94
#define LSW g7
95
#else
96
#define LSW g6
97
#define MSW g7
98
#endif
99
 
100
        .globl  _strncat
101
        .globl  __strncat
102
        .leafproc       _strncat, __strncat
103
        .align  2
104
_strncat:
105
#ifndef __PIC
106
        lda     Lrett,g14
107
#else
108
        lda     Lrett-(.+8)(ip),g14
109
#endif
110
__strncat:
111
        notand  g0,3,g4         # extract word addr of start of dest
112
         lda    (g14),g13       # preserve return address
113
        cmpibge.f 0,g2,Lexit_code # Lexit if number of bytes to move is <= zero.
114
        and     g0,3,LSW        # extract byte offset of dest
115
         ld     (g4),MSW        # fetch word containing at least first byte
116
        shlo    3,LSW,g14       # get shift count for making mask for first word
117
        subi    1,0,LSW         # mask initially all ones
118
#if __i960_BIG_ENDIAN__
119
        shro    g14,LSW,LSW     # get mask for bytes needed from first word
120
#else
121
        shlo    g14,LSW,LSW     # get mask for bytes needed from first word
122
#endif
123
        notor   MSW,LSW,MSW     # set unneeded bytes to all ones
124
         lda    0xff,g5         # byte extraction mask
125
Lsearch_for_word_with_null:
126
        scanbyte 0,MSW          # check for null byte
127
         lda    4(g4),g4        # post-increment dest word pointer
128
        mov     MSW,LSW         # keep a copy of current word
129
         ld     (g4),MSW        # fetch next word of dest
130
         bno.t  Lsearch_for_word_with_null      # branch if null not found yet
131
#if __i960_BIG_ENDIAN__
132
        shro    24,LSW,g14      # extract byte
133
#else
134
        and     g5,LSW,g14      # extract byte
135
#endif
136
        cmpo    0,g14           # branch if null is first byte of word
137
        subo    4,g4,g4         # move dest word ptr to word with null
138
        notand  g1,3,g3         # extract word addr of start of src
139
         bne.t  Lsearch_for_null
140
 
141
Lcase_14:
142
        cmpo    g1,g3           # check alignment of source
143
         ld     (g3),LSW        # fetch first word of source
144
        shlo    3,g1,g14        # compute shift count
145
         lda    4(g3),g3        # post-increment src addr
146
         bne.f  Lcase_4         # branch if source is unaligned
147
Lcase_1:
148
Lcase_1_wloop:                  # word copying loop
149
        cmpi    g2,4            # check for fewer than four bytes to move
150
         lda    (LSW),g1        # keep a copy of the src word
151
         bl.f   Lcase_1_cloop   # branch if fewer than four bytes to copy
152
        scanbyte 0,g1           # check for null byte in src word
153
         ld     (g3),LSW        # pre-fetch next word of src
154
        addo    4,g3,g3         # post-increment src addr
155
         bo.f   Lcase_1_cloop   # branch if word contains null byte
156
        subi    4,g2,g2         # decrease max_byte count by the 4 bytes moved
157
         st     g1,(g4)         # store word in dest string
158
        addo    4,g4,g4         # post-increment dest addr
159
         b      Lcase_1_wloop
160
 
161
Lcase_3_cloop:
162
Lcase_1_cloop:                  # character copying loop (max_bytes <= 3)
163
        cmpdeci 0,g2,g2         # is max_bytes exhausted?
164
#if __i960_BIG_ENDIAN__
165
        rotate  8,g1,g1         # move next byte into position for extraction
166
#endif
167
        and     g5,g1,g14       # extract next char
168
        be.f    Lstore_null     # if max_bytes is exhausted, store null and quit
169
        cmpo    0,g14           # check for null byte
170
         stob   g14,(g4)        # store the byte in dest
171
#if ! __i960_BIG_ENDIAN__
172
        shro    8,g1,g1         # move next byte into position for extraction
173
#endif
174
         lda    1(g4),g4        # post-increment dest byte addr
175
         bne.t  Lcase_1_cloop   # branch if null not reached
176
        bx      (g13)           # Lexit (g14 == 0)
177
 
178
Lstore_null:
179
        mov     0,g14           # store null, and set g14 to zero
180
        stob    g14,(g4)
181
        bx      (g13)
182
 
183
 
184
Lsearch_for_null:
185
#if __i960_BIG_ENDIAN__
186
        shlo    8,LSW,LSW       # check next byte
187
        shro    24,LSW,g14
188
#else
189
        shlo    8,g5,g5         # move mask up to next byte
190
        and     g5,LSW,g14      # extract byte
191
#endif
192
         lda    1(g4),g4        # move dest byte ptr to next byte
193
        cmpobne.t 0,g14,Lsearch_for_null        # branch if null is not yet found
194
 
195
Lcase_235:
196
        cmpo    g1,g3           # check alignment of src
197
         ld     (g3),LSW        # pre-fetch word with start of src
198
        and     3,g1,g1         # compute shift count
199
         lda    0xff,g5         # load mask for byte extraction
200
        shlo    3,g1,g14
201
         lda    4(g3),g3        # post-increment src word counter
202
         be.t   Lcase_3         # branch if src is word aligned
203
        and     g4,3,MSW        # extract byte offset for dest string
204
        cmpo    MSW,g1          # < indicates first word of dest has more bytes
205
                                /* than first word of source. */
206
         ld     (g3),MSW        # fetch second word of src
207
#if __i960_BIG_ENDIAN__
208
        subo    g14,0,g14       # adjust shift count for big endian
209
#endif
210
        eshro   g14,g6,g5       # extract four bytes
211
#if __i960_BIG_ENDIAN__
212
         bge.f  1f
213
#else
214
         bg.f   1f
215
#endif
216
        mov     MSW,LSW
217
         lda    4(g3),g3        # move src word addr to second word boundary
218
1:
219
        mov     g5,MSW
220
         lda    0xff,g5
221
         b      Lcase_25
222
 
223
Lcase_3:                                # src is word aligned; dest is not
224
        mov     LSW,MSW         # make copy of first word of src
225
         lda    32,g14          # initialize shift count to zero (mod 32)
226
Lcase_25:
227
 
228
Lcase_3_cloop_at_start:         # character copying loop for start of dest str
229
        cmpdeci 0,g2,g2         # is max_bytes exhausted?
230
#if __i960_BIG_ENDIAN__
231
        shro    24,MSW,g5       # extract next char
232
#else
233
        and     g5,MSW,g5       # extract next char
234
#endif
235
         be.f   Lstore_null     # Lexit if max_bytes is exhausted
236
        cmpo    0,g5            # check for null byte
237
         stob   g5,(g4)         # store the byte in dest
238
        addo    1,g4,g4         # post-increment dest ptr
239
         lda    0xff,g5         # re-initialize byte extraction mask
240
        notand  g4,3,g1         # extract word address
241
         be.t   Lexit_code      # Lexit if null byte reached
242
        cmpo    g1,g4           # have we reached word boundary in dest yet?
243
#if __i960_BIG_ENDIAN__
244
         lda    -8(g14),g14     # augment the shift counter
245
        rotate  8,MSW,MSW       # move next byte into position for extraction
246
#else
247
         lda    8(g14),g14      # augment the shift counter
248
        shro    8,MSW,MSW       # move next byte into position for extraction
249
#endif
250
         bne.t  Lcase_3_cloop_at_start  # branch if reached word boundary?
251
 
252
#if __i960_BIG_ENDIAN__
253
        cmpo    0,g14
254
         ld     (g3),MSW        # fetch msw of operand for double shift
255
        bne     Lcase_3_wloop   # branch if src is still unaligned.
256
 
257
Lcase_3_wloop2:
258
        cmpi    g2,4            # less than four bytes to move?
259
        mov     LSW,g1          # extract 4 bytes of src
260
         lda    4(g3),g3        # post-increment src word addr
261
         bl.f   Lcase_3_cloop   # branch if < four bytes left to move
262
        scanbyte 0,g1           # check for null byte
263
        mov     MSW,LSW         # move msw to lsw
264
         ld     (g3),MSW        # pre-fetch msw of operand for double shift
265
         bo.f   Lcase_3_cloop   # branch if word contains null byte
266
        subi    4,g2,g2         # decrease max_byte count by the 4 bytes moved
267
         st     g1,(g4)         # store 4 bytes to dest
268
        addo    4,g4,g4         # post-increment dest ptr
269
         b      Lcase_3_wloop2
270
Lcase_4:
271
        subo    g14,0,g14       # adjust shift count for big endian
272
#else
273
Lcase_4:
274
#endif
275
 
276
        ld      (g3),MSW        # fetch msw of operand for double shift
277
 
278
Lcase_3_wloop:
279
        cmpi    g2,4            # less than four bytes to move?
280
        eshro   g14,g6,g1       # extract 4 bytes of src
281
         lda    4(g3),g3        # post-increment src word addr
282
         bl.f   Lcase_3_cloop   # branch if < four bytes left to move
283
        scanbyte 0,g1           # check for null byte
284
        mov     MSW,LSW         # move msw to lsw
285
         ld     (g3),MSW        # pre-fetch msw of operand for double shift
286
         bo.f   Lcase_3_cloop   # branch if word contains null byte
287
        subi    4,g2,g2         # decrease max_byte count by the 4 bytes moved
288
         st     g1,(g4)         # store 4 bytes to dest
289
        addo    4,g4,g4         # post-increment dest ptr
290
         b      Lcase_3_wloop
291
 
292
 
293
Lexit_code:
294
        mov     0,g14           # conform to register conventions
295
        bx      (g13)           # g0 = addr of dest;  g14 = 0
296
Lrett:
297
        ret
298
 
299
/* end of strncat */
300
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.