sysdeps/m68k/memcopy.h

   1 /* memcopy.h -- definitions for memory copy functions.  Motorola 68020 version.
   2    Copyright (C) 1991-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library.  If not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <sysdeps/generic/memcopy.h>
  20
  21 #if     defined(__mc68020__) || defined(mc68020)
  22
  23 /* WORD_COPY_FWD and WORD_COPY_BWD are not symmetric on the 68020,
  24    because of its weird instruction overlap characteristics.  */
  25
  26 #undef  WORD_COPY_FWD
  27 #define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)                    \
  28   do                                                                          \
  29     {                                                                         \
  30       size_t __nwords = (nbytes) / sizeof (op_t);                             \
  31       size_t __nblocks = __nwords / 8 + 1;                                    \
  32       dst_bp -= (8 - __nwords % 8) * sizeof (op_t);                           \
  33       src_bp -= (8 - __nwords % 8) * sizeof (op_t);                           \
  34       switch (__nwords % 8)                                                   \
  35         do                                                                    \
  36           {                                                                   \
  37             ((op_t *) dst_bp)[0] = ((op_t *) src_bp)[0];                      \
  38             /* Fall through.  */                                              \
  39           case 7:                                                             \
  40             ((op_t *) dst_bp)[1] = ((op_t *) src_bp)[1];                      \
  41             /* Fall through.  */                                              \
  42           case 6:                                                             \
  43             ((op_t *) dst_bp)[2] = ((op_t *) src_bp)[2];                      \
  44             /* Fall through.  */                                              \
  45           case 5:                                                             \
  46             ((op_t *) dst_bp)[3] = ((op_t *) src_bp)[3];                      \
  47             /* Fall through.  */                                              \
  48           case 4:                                                             \
  49             ((op_t *) dst_bp)[4] = ((op_t *) src_bp)[4];                      \
  50             /* Fall through.  */                                              \
  51           case 3:                                                             \
  52             ((op_t *) dst_bp)[5] = ((op_t *) src_bp)[5];                      \
  53             /* Fall through.  */                                              \
  54           case 2:                                                             \
  55             ((op_t *) dst_bp)[6] = ((op_t *) src_bp)[6];                      \
  56             /* Fall through.  */                                              \
  57           case 1:                                                             \
  58             ((op_t *) dst_bp)[7] = ((op_t *) src_bp)[7];                      \
  59             /* Fall through.  */                                              \
  60           case 0:                                                             \
  61             src_bp += 32;                                                     \
  62             dst_bp += 32;                                                     \
  63             __nblocks--;                                                      \
  64           }                                                                   \
  65       while (__nblocks != 0);                                                 \
  66       (nbytes_left) = (nbytes) % sizeof (op_t);                               \
  67     } while (0)
  68
  69 #undef  WORD_COPY_BWD
  70 #define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes)                    \
  71   do                                                                          \
  72     {                                                                         \
  73       size_t __nblocks = (nbytes) / 32 + 1;                                   \
  74       op_t *__dst_ep = (op_t *) (dst_ep);                                     \
  75       op_t *__src_ep = (op_t *) (src_ep);                                     \
  76       switch ((nbytes) / sizeof (op_t) % 8)                                   \
  77         do                                                                    \
  78           {                                                                   \
  79             *--__dst_ep = *--__src_ep;                                        \
  80             /* Fall through.  */                                              \
  81           case 7:                                                             \
  82             *--__dst_ep = *--__src_ep;                                        \
  83             /* Fall through.  */                                              \
  84           case 6:                                                             \
  85             *--__dst_ep = *--__src_ep;                                        \
  86             /* Fall through.  */                                              \
  87           case 5:                                                             \
  88             *--__dst_ep = *--__src_ep;                                        \
  89             /* Fall through.  */                                              \
  90           case 4:                                                             \
  91             *--__dst_ep = *--__src_ep;                                        \
  92             /* Fall through.  */                                              \
  93           case 3:                                                             \
  94             *--__dst_ep = *--__src_ep;                                        \
  95             /* Fall through.  */                                              \
  96           case 2:                                                             \
  97             *--__dst_ep = *--__src_ep;                                        \
  98             /* Fall through.  */                                              \
  99           case 1:                                                             \
 100             *--__dst_ep = *--__src_ep;                                        \
 101             /* Fall through.  */                                              \
 102           case 0:                                                             \
 103             __nblocks--;                                                      \
 104           }                                                                   \
 105       while (__nblocks != 0);                                                 \
 106       (nbytes_left) = (nbytes) % sizeof (op_t);                               \
 107       (dst_ep) = (unsigned long) __dst_ep;                                    \
 108       (src_ep) = (unsigned long) __src_ep;                                    \
 109     } while (0)
 110
 111 #endif