| blob | eebfa88a1c556532de16fedd5b1a92ee8ef6b997 |
1 /*******************************************************************************
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 ******************************************************************************/
31 .file "memcp_ca.s"
32 #ifdef __PIC
33 .pic
34 #endif
35 #ifdef __PID
36 .pid
37 #endif
38 /*
39 * (c) copyright 1988,1992,1993 Intel Corp., all rights reserved
40 */
42 /*
43 procedure memmove (optimized assembler version for the CA)
44 procedure memcpy (optimized assembler version for the CA)
46 dest_addr = memmove (dest_addr, src_addr, len)
47 dest_addr = memcpy (dest_addr, src_addr, len)
49 copy len bytes pointed to by src_addr to the space pointed to by
50 dest_addr. Return the original dest_addr.
52 Memcpy will fail if the source and destination string overlap
53 (in particular, if the end of the source is overlapped by the
54 beginning of the destination). The behavior is undefined.
55 This is acceptable according to the draft C standard.
56 Memmove will not fail if overlap exists.
58 Undefined behavior will also occur if the end of the source string
59 (i.e. the terminating null byte) is in the last word of the program's
60 allocated memory space. This is so because, in several cases, the
61 routine will fetch ahead one word. Disallowing the fetch ahead would
62 impose a severe performance penalty.
64 This program handles five cases:
66 1) both arguments start on a word boundary
67 2) neither are word aligned, but they are offset by the same amount
68 3) source is word aligned, destination is not
69 4) destination is word aligned, source is not
70 5) neither is word aligned, and they are offset by differing amounts
72 At the time of this writing, only g0 thru g7 and g13 are available
73 for use in this leafproc; other registers would have to be saved and
74 restored. These nine registers, plus tricky use of g14 are sufficient
75 to implement the routine. The registers are used as follows:
77 g0 dest ptr; not modified, so that it may be returned
78 g1 src ptr; shift count
79 g2 len
80 g3 src ptr (word aligned)
81 g4 dest ptr (word aligned)
82 g5 -4 for Lbackwards move
83 Little endian
84 g6 lsw of double word for extraction of 4 bytes
85 g7 msw of double word for extraction of 4 bytes
86 Big endian
87 g6 msw of double word for extraction of 4 bytes
88 g7 lsw of double word for extraction of 4 bytes
89 g13 return address
90 g14 byte extracted.
91 */
93 #if __i960_BIG_ENDIAN__
94 #define MSW g6
95 #define LSW g7
96 #else
97 #define LSW g6
98 #define MSW g7
99 #endif
101 .globl _memmove, _memcpy
102 .globl __memmove, __memcpy
103 .leafproc _memmove, __memmove
104 .leafproc _memcpy, __memcpy
105 .align 2
106 _memcpy:
107 _memmove:
108 #ifndef __PIC
109 lda Lrett,g14
110 #else
111 lda Lrett-(.+8)(ip),g14
112 #endif
113 __memcpy:
114 __memmove:
115 cmpibge.f 0,g2,Lquick_exit # Lexit if number of bytes to move is <= zero.
116 cmpo g0,g1 # if dest starts earlier than src ...
117 lda (g14),g13 # preserve return address
118 addo g2,g1,g5 # compute addr of byte after last byte of src
119 be.f Lexit_code # no move necessary if src and dest are same
120 concmpo g5,g0 # ... or if dest starts after end of src ...
121 notand g1,3,g3 # extract word addr of start of src
122 bg.f Lbackwards # ... then drop thru, else do move backwards
123 cmpo g3,g1 # check alignment of src
124 ld (g3),LSW # fetch word containing at least first byte
125 notand g0,3,g4 # extract word addr of start of dest
126 lda 4(g3),g3 # advance src word addr
127 bne.f Lcase_245 # branch if src is NOT word aligned
129 Lcase_13:
130 cmpo g0,g4 # check alignment of dest
131 subo 4,g4,g4 # store is pre-incrementing; back up dest addr
132 be.t Lcase_1 # branch if dest word aligned
134 Lcase_3: # src is word aligned; dest is not
135 addo 8,g4,g4 # move dest word ptr to first word boundary
136 lda (g0),g1 # copy dest byte ptr
137 mov LSW,MSW # make copy of first word of src
138 lda 32,g14 # initialize shift count to zero (mod 32)
140 Lcase_25:
141 Lcase_3_cloop_at_start: # character copying loop for start of dest str
142 cmpdeci 0,g2,g2 # is max_bytes exhausted?
143 be.f Lexit_code # Lexit if max_bytes is exhausted
144 #if __i960_BIG_ENDIAN__
145 rotate 8,MSW,MSW # move next byte into position for extraction
146 subo 8,g14,g14 # augment the shift counter
147 stob MSW,(g1) # store the byte in dest
148 #else
149 addo 8,g14,g14 # augment the shift counter
150 stob MSW,(g1) # store the byte in dest
151 shro 8,MSW,MSW # move next byte into position for extraction
152 #endif
153 lda 1(g1),g1 # post-increment dest ptr
154 cmpobne.t g1,g4,Lcase_3_cloop_at_start # branch if reached word boundary
156 ld (g3),MSW # fetch msw of operand for double shift
158 Lcase_4:
159 Lcase_3_wloop:
160 cmpi g2,4 # less than four bytes to move?
161 lda 4(g3),g3 # post-increment src word addr
162 eshro g14,g6,g1 # extract 4 bytes of src
163 bl.f Lcase_3_cloop # branch if < four bytes left to move
164 mov MSW,LSW # move msw to lsw
165 ld (g3),MSW # pre-fetch msw of operand for double shift
166 subi 4,g2,g2 # decrease max_byte count by the 4 bytes moved
167 st g1,(g4) # store 4 bytes to dest
168 addo 4,g4,g4 # post-increment dest ptr
169 b Lcase_3_wloop
171 Lcase_1_wloop: # word copying loop
172 subi 4,g2,g2 # decrease max_byte count by the 4 bytes moved
173 ld (g3),LSW # pre-fetch next word of src
174 addo 4,g3,g3 # post-increment src addr
175 st g1,(g4) # store word in dest string
176 Lcase_1: # src and dest are word aligned
177 cmpi g2,4 # check for fewer than four bytes to move
178 addo 4,g4,g4 # pre-increment dest addr
179 lda (LSW),g1 # keep a copy of the src word
180 bge.t Lcase_1_wloop # branch if at least four bytes to copy
181 Lcase_3_cloop:
182 cmpibe.f 0,g2,Lexit_code # Lexit if max_bytes is exhausted
184 Lcase_1_cloop:
185 #if __i960_BIG_ENDIAN__
186 rotate 8,g1,g1 # move next byte into position for extraction
187 #endif
188 subi 1,g2,g2
189 stob g1,(g4) # store the byte in dest
190 cmpi 0,g2
191 lda 1(g4),g4 # post-increment dest byte addr
192 #if ! __i960_BIG_ENDIAN__
193 shro 8,g1,g1 # move next byte into position for extraction
194 #endif
195 bne.t Lcase_1_cloop # Lexit if max_bytes is exhausted
197 Lexit_code:
198 mov 0,g14 # conform to register conventions
199 bx (g13) # g0 = addr of dest; g14 = 0
200 Lrett:
201 ret
204 Lcase_245:
205 cmpo g0,g4 # check alignment of dest
206 ld (g3),MSW # pre-fetch second half
207 and 3,g1,g1 # compute shift count
208 shlo 3,g1,g14
209 #if __i960_BIG_ENDIAN__
210 subo g14,0,g14 # adjust shift count for big endian
211 #endif
212 be.t Lcase_4 # branch if dest is word aligned
213 or g4,g1,g1 # is src earlier in word, later, or sync w/ dst
214 cmpo g0,g1 # < indicates first word of dest has more bytes
215 lda 4(g4),g4 # move dest word addr to first word boundary
216 eshro g14,g6,g5 # extract four bytes
217 lda (g0),g1
218 #if __i960_BIG_ENDIAN__
219 bge.f 1f
220 #else
221 bg.f 1f
222 #endif
223 mov MSW,LSW
224 lda 4(g3),g3 # move src word addr to second word boundary
225 1:
226 mov g5,MSW
227 b Lcase_25
230 Lbackwards:
231 notand g5,3,MSW # extract word addr of byte after end of src
232 cmpo MSW,g5 # check alignment of end of src
233 subo 4,MSW,g3 # retreat src word addr
234 addo g2,g0,g1 # compute addr of byte after end of dest
235 notand g1,3,g4 # extract word addr of start of dest
236 bne.f Lcase.245 # branch if src is NOT word aligned
238 Lcase.13:
239 cmpo g1,g4 # check alignment of dest
240 ld (g3),MSW # fetch last word of src
241 subo 4,g3,g3 # retreat src word addr
242 be.t Lcase.1 # branch if dest word aligned
244 Lcase.3: # src is word aligned; dest is not
245 mov MSW,LSW # make copy of first word of src
246 lda 32,g14 # initialize shift count to zero (mod 32)
248 Lcase.25:
249 Lcase.3_cloop_at_start: # character copying loop for start of dest str
250 cmpdeci 0,g2,g2 # is max.bytes exhausted?
251 be.f Lexit_code # Lexit if max_bytes is exhausted
252 #if ! __i960_BIG_ENDIAN__
253 rotate 8,LSW,LSW # move next byte into position for storing
254 #endif
255 lda -1(g1),g1 # pre-decrement dest ptr
256 cmpo g1,g4 # have we reached word boundary in dest yet?
257 stob LSW,(g1) # store the byte in dest
258 #if __i960_BIG_ENDIAN__
259 shro 8,LSW,LSW # move next byte into position for storing
260 addo 8,g14,g14 # augment the shift counter
261 #else
262 subo 8,g14,g14 # augment the shift counter
263 #endif
264 bne.t Lcase.3_cloop_at_start # branch if reached word boundary?
266 ld (g3),LSW # fetch lsw of operand for double shift
268 #if __i960_BIG_ENDIAN__
269 cmpobne 0,g14,Lcase.3_wloop
270 Lcase.3_wloop2:
271 cmpi g2,4 # less than four bytes to move?
272 lda -4(g3),g3 # post-decrement src word addr
273 mov MSW,g1 # extract 4 bytes of src
274 lda (LSW),MSW # move lsw to msw
275 subo 4,g4,g4 # pre-decrement dest ptr
276 bl.f Lcase.3_cloop # branch if < four bytes left to move
277 ld (g3),LSW # pre-fetch lsw of operand for double shift
278 subi 4,g2,g2 # decrease max.byte count by the 4 bytes moved
279 st g1,(g4) # store 4 bytes to dest
280 b Lcase.3_wloop2
281 #endif
283 Lcase.4:
284 Lcase.3_wloop:
285 cmpi g2,4 # less than four bytes to move?
286 lda -4(g3),g3 # post-decrement src word addr
287 eshro g14,g6,g1 # extract 4 bytes of src
288 lda (LSW),MSW # move lsw to msw
289 subo 4,g4,g4 # pre-decrement dest ptr
290 bl.f Lcase.3_cloop # branch if < four bytes left to move
291 ld (g3),LSW # pre-fetch lsw of operand for double shift
292 subi 4,g2,g2 # decrease max.byte count by the 4 bytes moved
293 st g1,(g4) # store 4 bytes to dest
294 b Lcase.3_wloop
296 Lcase.1_wloop: # word copying loop
297 subi 4,g2,g2 # decrease max.byte count by the 4 bytes moved
298 ld (g3),MSW # pre-fetch next word of src
299 subo 4,g3,g3 # post-decrement src addr
300 st g1,(g4) # store word in dest string
301 Lcase.1: # src and dest are word aligned
302 cmpi g2,4 # check for fewer than four bytes to move
303 subo 4,g4,g4 # pre-decrement dest addr
304 lda (MSW),g1 # keep a copy of the src word
305 bge.t Lcase.1_wloop # branch if at least four bytes to copy
306 Lcase.3_cloop:
307 cmpibe.f 0,g2,Lexit_code # Lexit if max_bytes is exhausted
308 #if ! __i960_BIG_ENDIAN__
309 rotate 8,g1,g1 # move next byte into position for storing
310 #endif
311 lda 4(g4),g4 # pre-decremented dest addr 4 too much
313 Lcase.1_cloop:
314 subi 1,g4,g4 # pre-decrement dest byte addr
315 cmpi g4,g0 # has dest ptr reached beginning of dest?
316 stob g1,(g4) # store the byte in dest
317 #if __i960_BIG_ENDIAN__
318 shro 8,g1,g1 # move next byte into position for storing
319 #else
320 rotate 8,g1,g1 # move next byte into position for storing
321 #endif
322 bne.t Lcase.1_cloop # Lexit if move is completed
323 b Lexit_code
325 Lcase.245:
326 cmpo g1,g4 # check alignment of dest
327 ld (MSW),MSW # pre-fetch word with at least last byte
328 and 3,g5,g5 # compute shift count
329 ld (g3),LSW # pre-fetch second to last word
330 shlo 3,g5,g14
331 #if __i960_BIG_ENDIAN__
332 subo g14,0,g14 # adjust shift count for big endian
333 #endif
334 be.t Lcase.4 # branch if dest is word aligned
335 or g4,g5,g5 # is src earlier in word, later, or sync w/ dst
336 cmpo g1,g5 # < indicates last word of dest has less bytes
337 eshro g14,g6,g5 # extract four bytes
338 bl.t 1f
339 mov LSW,MSW
340 #if ! __i960_BIG_ENDIAN__
341 be.t 1f
342 #endif
343 subo 4,g3,g3 # move src word addr to second word boundary
344 1:
345 mov g5,LSW
346 b Lcase.25
349 Lquick_exit:
350 mov g14,g13
351 b Lexit_code
353 /* end of memmove */