Mon Jun 24 19:57:01 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
[kopensolaris-gnu/glibc.git] / sysdeps / m68k / memcopy.h
1 /* memcopy.h -- definitions for memory copy functions.  Motorola 68020 version.
2    Copyright (C) 1991 Free Software Foundation, Inc.
3    Contributed by Torbjorn Granlund (tege@sics.se).
4
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.
9
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.
14
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
17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
18 Cambridge, MA 02139, USA.  */
19
20 #include <sysdeps/generic/memcopy.h>
21
22 #if     defined(__mc68020__) || defined(mc68020)
23
24 #undef  OP_T_THRES
25 #define OP_T_THRES      16
26
27 /* WORD_COPY_FWD and WORD_COPY_BWD are not symmetric on the 68020,
28    because of its weird instruction overlap characteristics.  */
29
30 #undef  WORD_COPY_FWD
31 #define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)                    \
32   do                                                                          \
33     {                                                                         \
34       size_t __nwords = (nbytes) / sizeof (op_t);                             \
35       size_t __nblocks = __nwords / 8 + 1;                                    \
36       dst_bp -= (8 - __nwords % 8) * sizeof (op_t);                           \
37       src_bp -= (8 - __nwords % 8) * sizeof (op_t);                           \
38       switch (__nwords % 8)                                                   \
39         do                                                                    \
40           {                                                                   \
41             ((op_t *) dst_bp)[0] = ((op_t *) src_bp)[0];                      \
42           case 7:                                                             \
43             ((op_t *) dst_bp)[1] = ((op_t *) src_bp)[1];                      \
44           case 6:                                                             \
45             ((op_t *) dst_bp)[2] = ((op_t *) src_bp)[2];                      \
46           case 5:                                                             \
47             ((op_t *) dst_bp)[3] = ((op_t *) src_bp)[3];                      \
48           case 4:                                                             \
49             ((op_t *) dst_bp)[4] = ((op_t *) src_bp)[4];                      \
50           case 3:                                                             \
51             ((op_t *) dst_bp)[5] = ((op_t *) src_bp)[5];                      \
52           case 2:                                                             \
53             ((op_t *) dst_bp)[6] = ((op_t *) src_bp)[6];                      \
54           case 1:                                                             \
55             ((op_t *) dst_bp)[7] = ((op_t *) src_bp)[7];                      \
56           case 0:                                                             \
57             src_bp += 32;                                                     \
58             dst_bp += 32;                                                     \
59             __nblocks--;                                                      \
60           }                                                                   \
61       while (__nblocks != 0);                                                 \
62       (nbytes_left) = (nbytes) % sizeof (op_t);                               \
63     } while (0)
64
65 #undef  WORD_COPY_BWD
66 #define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes)                    \
67   do                                                                          \
68     {                                                                         \
69       size_t __nblocks = (nbytes) / 32 + 1;                                   \
70       switch ((nbytes) / sizeof (op_t) % 8)                                   \
71         do                                                                    \
72           {                                                                   \
73             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
74           case 7:                                                             \
75             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
76           case 6:                                                             \
77             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
78           case 5:                                                             \
79             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
80           case 4:                                                             \
81             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
82           case 3:                                                             \
83             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
84           case 2:                                                             \
85             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
86           case 1:                                                             \
87             *--((op_t *) dst_ep) = *--((op_t *) src_ep);                      \
88           case 0:                                                             \
89             __nblocks--;                                                      \
90           }                                                                   \
91       while (__nblocks != 0);                                                 \
92       (nbytes_left) = (nbytes) % sizeof (op_t);                               \
93     } while (0)
94
95 #endif