]>
Commit | Line | Data |
---|---|---|
28f540f4 | 1 | /* memcopy.h -- definitions for memory copy functions. Generic C version. |
c84142e8 | 2 | Copyright (C) 1991, 1992, 1993, 1997 Free Software Foundation, Inc. |
28f540f4 RM |
3 | Contributed by Torbjorn Granlund (tege@sics.se). |
4 | ||
c84142e8 UD |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Library General Public License as | |
7 | published by the Free Software Foundation; either version 2 of the | |
8 | License, or (at your option) any later version. | |
28f540f4 | 9 | |
c84142e8 UD |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 | Library General Public License for more details. | |
28f540f4 | 14 | |
c84142e8 UD |
15 | You should have received a copy of the GNU Library General Public |
16 | License along with the GNU C Library; see the file COPYING.LIB. If not, | |
17 | write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
18 | Boston, MA 02111-1307, USA. */ | |
28f540f4 RM |
19 | |
20 | /* The strategy of the memory functions is: | |
21 | ||
22 | 1. Copy bytes until the destination pointer is aligned. | |
23 | ||
24 | 2. Copy words in unrolled loops. If the source and destination | |
25 | are not aligned in the same way, use word memory operations, | |
26 | but shift and merge two read words before writing. | |
27 | ||
28 | 3. Copy the few remaining bytes. | |
29 | ||
30 | This is fast on processors that have at least 10 registers for | |
31 | allocation by GCC, and that can access memory at reg+const in one | |
32 | instruction. | |
33 | ||
34 | I made an "exhaustive" test of this memmove when I wrote it, | |
35 | exhaustive in the sense that I tried all alignment and length | |
36 | combinations, with and without overlap. */ | |
37 | ||
38 | #include <sys/cdefs.h> | |
39 | #include <endian.h> | |
40 | ||
41 | /* The macros defined in this file are: | |
42 | ||
43 | BYTE_COPY_FWD(dst_beg_ptr, src_beg_ptr, nbytes_to_copy) | |
44 | ||
45 | BYTE_COPY_BWD(dst_end_ptr, src_end_ptr, nbytes_to_copy) | |
46 | ||
47 | WORD_COPY_FWD(dst_beg_ptr, src_beg_ptr, nbytes_remaining, nbytes_to_copy) | |
48 | ||
49 | WORD_COPY_BWD(dst_end_ptr, src_end_ptr, nbytes_remaining, nbytes_to_copy) | |
50 | ||
51 | MERGE(old_word, sh_1, new_word, sh_2) | |
52 | [I fail to understand. I feel stupid. --roland] | |
53 | */ | |
54 | ||
55 | /* Type to use for aligned memory operations. | |
56 | This should normally be the biggest type supported by a single load | |
57 | and store. */ | |
58 | #define op_t unsigned long int | |
59 | #define OPSIZ (sizeof(op_t)) | |
60 | ||
61 | /* Type to use for unaligned operations. */ | |
62 | typedef unsigned char byte; | |
63 | ||
64 | /* Optimal type for storing bytes in registers. */ | |
65 | #define reg_char char | |
66 | ||
67 | #if __BYTE_ORDER == __LITTLE_ENDIAN | |
68 | #define MERGE(w0, sh_1, w1, sh_2) (((w0) >> (sh_1)) | ((w1) << (sh_2))) | |
69 | #endif | |
70 | #if __BYTE_ORDER == __BIG_ENDIAN | |
71 | #define MERGE(w0, sh_1, w1, sh_2) (((w0) << (sh_1)) | ((w1) >> (sh_2))) | |
72 | #endif | |
73 | ||
74 | /* Copy exactly NBYTES bytes from SRC_BP to DST_BP, | |
75 | without any assumptions about alignment of the pointers. */ | |
76 | #define BYTE_COPY_FWD(dst_bp, src_bp, nbytes) \ | |
77 | do \ | |
78 | { \ | |
79 | size_t __nbytes = (nbytes); \ | |
80 | while (__nbytes > 0) \ | |
81 | { \ | |
82 | byte __x = ((byte *) src_bp)[0]; \ | |
83 | src_bp += 1; \ | |
84 | __nbytes -= 1; \ | |
85 | ((byte *) dst_bp)[0] = __x; \ | |
86 | dst_bp += 1; \ | |
87 | } \ | |
88 | } while (0) | |
89 | ||
90 | /* Copy exactly NBYTES_TO_COPY bytes from SRC_END_PTR to DST_END_PTR, | |
91 | beginning at the bytes right before the pointers and continuing towards | |
92 | smaller addresses. Don't assume anything about alignment of the | |
93 | pointers. */ | |
94 | #define BYTE_COPY_BWD(dst_ep, src_ep, nbytes) \ | |
95 | do \ | |
96 | { \ | |
97 | size_t __nbytes = (nbytes); \ | |
98 | while (__nbytes > 0) \ | |
99 | { \ | |
100 | byte __x; \ | |
101 | src_ep -= 1; \ | |
102 | __x = ((byte *) src_ep)[0]; \ | |
103 | dst_ep -= 1; \ | |
104 | __nbytes -= 1; \ | |
105 | ((byte *) dst_ep)[0] = __x; \ | |
106 | } \ | |
107 | } while (0) | |
108 | ||
109 | /* Copy *up to* NBYTES bytes from SRC_BP to DST_BP, with | |
110 | the assumption that DST_BP is aligned on an OPSIZ multiple. If | |
111 | not all bytes could be easily copied, store remaining number of bytes | |
112 | in NBYTES_LEFT, otherwise store 0. */ | |
113 | extern void _wordcopy_fwd_aligned __P ((long int, long int, size_t)); | |
114 | extern void _wordcopy_fwd_dest_aligned __P ((long int, long int, size_t)); | |
115 | #define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes) \ | |
116 | do \ | |
117 | { \ | |
118 | if (src_bp % OPSIZ == 0) \ | |
119 | _wordcopy_fwd_aligned (dst_bp, src_bp, (nbytes) / OPSIZ); \ | |
120 | else \ | |
121 | _wordcopy_fwd_dest_aligned (dst_bp, src_bp, (nbytes) / OPSIZ); \ | |
122 | src_bp += (nbytes) & -OPSIZ; \ | |
123 | dst_bp += (nbytes) & -OPSIZ; \ | |
124 | (nbytes_left) = (nbytes) % OPSIZ; \ | |
125 | } while (0) | |
126 | ||
127 | /* Copy *up to* NBYTES_TO_COPY bytes from SRC_END_PTR to DST_END_PTR, | |
128 | beginning at the words (of type op_t) right before the pointers and | |
129 | continuing towards smaller addresses. May take advantage of that | |
130 | DST_END_PTR is aligned on an OPSIZ multiple. If not all bytes could be | |
131 | easily copied, store remaining number of bytes in NBYTES_REMAINING, | |
132 | otherwise store 0. */ | |
133 | extern void _wordcopy_bwd_aligned __P ((long int, long int, size_t)); | |
134 | extern void _wordcopy_bwd_dest_aligned __P ((long int, long int, size_t)); | |
135 | #define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes) \ | |
136 | do \ | |
137 | { \ | |
138 | if (src_ep % OPSIZ == 0) \ | |
139 | _wordcopy_bwd_aligned (dst_ep, src_ep, (nbytes) / OPSIZ); \ | |
140 | else \ | |
141 | _wordcopy_bwd_dest_aligned (dst_ep, src_ep, (nbytes) / OPSIZ); \ | |
142 | src_ep -= (nbytes) & -OPSIZ; \ | |
143 | dst_ep -= (nbytes) & -OPSIZ; \ | |
144 | (nbytes_left) = (nbytes) % OPSIZ; \ | |
145 | } while (0) | |
146 | ||
147 | ||
148 | /* Threshold value for when to enter the unrolled loops. */ | |
149 | #define OP_T_THRES 16 |