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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [newlib/] [newlib/] [libc/] [machine/] [i960/] [memccpy_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 "mccpy_ca.s"
32
#ifdef  __PIC
33
        .pic
34
#endif
35
#ifdef  __PID
36
        .pid
37
#endif
38
/*
39
 * (c) copyright 1989,1993 Intel Corp., all rights reserved
40
 */
41
 
42
/*
43
        procedure memccpy  (optimized assembler version for the 80960CA)
44
 
45
        dest_addr = memccpy (dest_addr, src_addr, char, len)
46
 
47
        copy len bytes pointed to by src_addr to the space pointed to by
48
        dest_addr, stopping if char is copied.  If char is copied,
49
        return address of byte after char in dest string;  else null.
50
 
51
        Undefined behavior will occur if the end of the source array is in
52
        the last two words of the program's allocated memory space.  This
53
        is so because the routine fetches ahead.  Disallowing the fetch
54
        ahead would impose a severe performance penalty.
55
 
56
        Undefined behavior will also occur if the source and destination
57
        strings overlap.
58
 
59
 
60
        This program handles five cases:
61
 
62
        1) both arguments start on a word boundary
63
        2) neither are word aligned, but they are offset by the same amount
64
        3) source is word aligned, destination is not
65
        4) destination is word aligned, source is not
66
        5) neither is word aligned, and they are offset by differing amounts
67
 
68
        At the time of this writing, only g0 thru g7 and g13 are available
69
        for use in this leafproc;  other registers would have to be saved and
70
        restored.  These nine registers, plus tricky use of g14 are sufficient
71
        to implement the routine.
72
*/
73
 
74
#if __i960_BIG_ENDIAN__
75
#define MSW g6
76
#define LSW g7
77
#else
78
#define LSW g6
79
#define MSW g7
80
#endif
81
 
82
        .globl  _memccpy
83
        .leafproc       _memccpy, __memccpy
84
        .align  2
85
_memccpy:
86
#ifndef __PIC
87
        lda     Lrett,g14
88
#else
89
        lda     Lrett-(.+8)(ip),g14
90
#endif
91
__memccpy:
92
        notand  g1,3,g5         # extract word addr of start of src
93
         lda    (g14),g13       # preserve return address
94
        cmpibge.f 0,g3,Lexit_char_not_found # Lexit if # of bytes to move is <= 0
95
        cmpo    g5,g1           # check alignment of src
96
         ld     (g5),LSW        # fetch word containing at least first byte
97
        notand  g0,3,g4         # extract word addr of start of dest
98
         lda    4(g5),g5        # advance src word addr
99
        shlo    24,g2,g2        # reduce char to single byte
100
         bne.f  Lcase_245       # branch if src is NOT word aligned
101
 
102
Lcase_13:
103
        cmpobe.t g0,g4,Lcase_1_setup    # branch if dest word aligned
104
 
105
Lcase_3:                                # src is word aligned; dest is not
106
        mov     LSW,MSW         # make copy of first word of src
107
        addo    4,g4,g1         # move dest word ptr to first word boundary
108
         lda    32,g14          # initialize shift count to zero
109
 
110
Lcase_25:
111
Lcase_3_cloop_at_start:         # character copying loop for start of dest str
112
        cmpdeci 0,g3,g3         # is max_bytes exhausted?
113
#if __i960_BIG_ENDIAN__
114
         lda    -8(g14),g14     # augment the shift counter
115
#else
116
         lda    8(g14),g14      # augment the shift counter
117
#endif
118
        be.f    Lexit_char_not_found    # Lexit if max_bytes is exhausted
119
#if __i960_BIG_ENDIAN__
120
        rotate  8,MSW,MSW       # move next byte into position for extraction
121
#endif
122
        shlo    24,MSW,g4
123
         stob   MSW,(g0)        # store the byte in dest
124
        cmpo    g4,g2
125
         lda    1(g0),g0        # post-increment dest ptr
126
#if ! __i960_BIG_ENDIAN__
127
        shro    8,MSW,MSW       # move next byte into position for extraction
128
#endif
129
         be.f   Lexit_char_found        # Lexit if char found
130
        cmpobne.t g1,g0,Lcase_3_cloop_at_start # branch if reached word boundary
131
 
132
        ld      (g5),MSW        # fetch msw of operand for double shift
133
 
134
Lcase_4:
135
        shro    8,g2,g4
136
        or      g4,g2,g1
137
        shro    16,g1,g4
138
        or      g4,g1,g4
139
 
140
#if __i960_BIG_ENDIAN__
141
        cmpobne 0,g14,Lcase_3_wloop
142
 
143
Lcase_3_wloop2:
144
        cmpi    g3,4            # less than four bytes to move?
145
         lda    4(g5),g5        # post-increment src word addr
146
        mov     LSW,g1          # extract 4 bytes of src
147
         bl.f   Lcase_13_cloop_setup    # branch if < four bytes left to move
148
        scanbyte g4,g1          # branch if word has char in it
149
         bo.f   Lcase_13_cloop_setup
150
        mov     MSW,LSW         # move msw to lsw
151
         ld     (g5),MSW        # pre-fetch msw of operand for double shift
152
        subi    4,g3,g3         # decrease max_byte count by the 4 bytes moved
153
         st     g1,(g0)         # store 4 bytes to dest
154
        addo    4,g0,g0         # post-increment dest ptr
155
         b      Lcase_3_wloop2
156
#endif
157
 
158
Lcase_3_wloop:
159
        cmpi    g3,4            # less than four bytes to move?
160
         lda    4(g5),g5        # post-increment src word addr
161
        eshro   g14,g6,g1       # extract 4 bytes of src
162
         bl.f   Lcase_13_cloop_setup    # branch if < four bytes left to move
163
        scanbyte g4,g1          # branch if word has char in it
164
         bo.f   Lcase_13_cloop_setup
165
        mov     MSW,LSW         # move msw to lsw
166
         ld     (g5),MSW        # pre-fetch msw of operand for double shift
167
        subi    4,g3,g3         # decrease max_byte count by the 4 bytes moved
168
         st     g1,(g0)         # store 4 bytes to dest
169
        addo    4,g0,g0         # post-increment dest ptr
170
         b      Lcase_3_wloop
171
 
172
Lcase_1_setup:
173
        subo    4,g0,g0         # store is pre-incrementing;  back up dest addr
174
        shro    8,g2,g4
175
        or      g4,g2,MSW
176
        shro    16,MSW,g4
177
        or      g4,MSW,g4
178
         b      Lcase_1
179
Lcase_1_wloop:                  # word copying loop
180
        subi    4,g3,g3         # decrease max_byte count by the 4 bytes moved
181
         ld     (g5),LSW        # pre-fetch next word of src
182
        addo    4,g5,g5         # post-increment src addr
183
         st     g1,(g0)         # store word in dest string
184
Lcase_1:                                # src and dest are word aligned
185
        cmpi    g3,4            # check for fewer than four bytes to move
186
        addo    4,g0,g0         # pre-increment dest addr
187
         lda    (LSW),g1        # keep a copy of the src word
188
         bl.f   Lcase_13_cloop_setup    # branch if less than four bytes to copy
189
        scanbyte LSW,g4         # branch if char is not in foursome
190
        bno.t   Lcase_1_wloop
191
Lcase_13_cloop_setup:
192
        cmpibe.f 0,g3,Lexit_char_not_found      # Lexit if max_bytes is exhausted
193
 
194
Lcase_1_cloop:
195
#if __i960_BIG_ENDIAN__
196
        rotate  8,g1,g1         # move next byte into position for extraction
197
#endif
198
        shlo    24,g1,g4
199
         stob   g1,(g0)         # store the byte in dest
200
        cmpo    g4,g2
201
         lda    1(g0),g0        # post-increment dest byte addr
202
        subi    1,g3,g3
203
         be.f   Lexit_char_found        # Lexit if char reached
204
        cmpi    0,g3
205
#if ! __i960_BIG_ENDIAN__
206
        shro    8,g1,g1         # move next byte into position for extraction
207
#endif
208
         bne.t  Lcase_1_cloop   # continue if len not exhausted
209
 
210
Lexit_char_not_found:
211
        mov     0,g0
212
Lexit_char_found:
213
        lda     0,g14
214
        bx      (g13)           # g0 = dest array address;  g14 = 0
215
Lrett:
216
        ret
217
 
218
 
219
Lcase_245:
220
        cmpo    g0,g4           # check alignment of dest
221
         ld     (g5),MSW        # pre-fetch second half
222
        and     3,g1,g1         # compute shift count
223
        shlo    3,g1,g14
224
#if __i960_BIG_ENDIAN__
225
        subo    g14,0,g14       # adjust shift count for big endian
226
#endif
227
         be.t   Lcase_4         # branch if dest is word aligned
228
        or      g4,g1,g1        # is src earlier in word, later, or sync w/ dst
229
        cmpo    g0,g1           # < indicates first word of dest has more bytes
230
                                /* than first word of source. */
231
        eshro   g14,g6,g4       # extract four bytes
232
         lda    4(g0),g1        # move dest word addr to first word boundary
233
#if __i960_BIG_ENDIAN__
234
         bge.f  1f
235
#else
236
         bg.f   1f
237
#endif
238
        mov     MSW,LSW
239
         lda    4(g5),g5        # move src word addr to second word boundary
240
1:
241
        notand  g1,3,g1
242
         mov    g4,MSW
243
         b      Lcase_25
244
 
245
/* end of memccpy */

powered by: WebSVN 2.1.0

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