sysdeps/powerpc/power6/wordcopy.c

   1 /* _memcopy.c -- subroutines for memory copy functions.
   2    Copyright (C) 1991-2024 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 /* BE VERY CAREFUL IF YOU CHANGE THIS CODE...!  */
  20
  21 #include <stddef.h>
  22 #include <memcopy.h>
  23
  24 /* _wordcopy_fwd_aligned -- Copy block beginning at SRCP to
  25    block beginning at DSTP with LEN `op_t' words (not LEN bytes!).
  26    Both SRCP and DSTP should be aligned for memory operations on `op_t's.  */
  27
  28 #ifndef WORDCOPY_FWD_ALIGNED
  29 # define WORDCOPY_FWD_ALIGNED _wordcopy_fwd_aligned
  30 #endif
  31
  32 void
  33 WORDCOPY_FWD_ALIGNED (long int dstp, long int srcp, size_t len)
  34 {
  35   op_t a0, a1;
  36
  37   if (len & 1)
  38   {
  39     ((op_t *) dstp)[0] = ((op_t *) srcp)[0];
  40
  41     if (len == 1)
  42       return;
  43     srcp += OPSIZ;
  44     dstp += OPSIZ;
  45     len -= 1;
  46   }
  47
  48   do
  49     {
  50       a0 = ((op_t *) srcp)[0];
  51       a1 = ((op_t *) srcp)[1];
  52       ((op_t *) dstp)[0] = a0;
  53       ((op_t *) dstp)[1] = a1;
  54
  55       srcp += 2 * OPSIZ;
  56       dstp += 2 * OPSIZ;
  57       len -= 2;
  58     }
  59   while (len != 0);
  60 }
  61
  62 /* _wordcopy_fwd_dest_aligned -- Copy block beginning at SRCP to
  63    block beginning at DSTP with LEN `op_t' words (not LEN bytes!).
  64    DSTP should be aligned for memory operations on `op_t's, but SRCP must
  65    *not* be aligned.  */
  66
  67 #define fwd_align_merge(align)                                         \
  68   do                                                                   \
  69     {                                                                  \
  70       a1 = ((op_t *) srcp)[1];                                         \
  71       a2 = ((op_t *) srcp)[2];                                         \
  72       ((op_t *) dstp)[0] = MERGE (a0, align*8, a1, (__WORDSIZE-align*8)); \
  73       ((op_t *) dstp)[1] = MERGE (a1, align*8, a2, (__WORDSIZE-align*8)); \
  74       a0 = a2;                                                         \
  75       srcp += 2 * OPSIZ;                                               \
  76       dstp += 2 * OPSIZ;                                               \
  77       len -= 2;                                                                \
  78     }                                                                  \
  79   while (len != 0)
  80
  81 #ifndef WORDCOPY_FWD_DEST_ALIGNED
  82 # define WORDCOPY_FWD_DEST_ALIGNED _wordcopy_fwd_dest_aligned
  83 #endif
  84
  85 void
  86 WORDCOPY_FWD_DEST_ALIGNED (long int dstp, long int srcp, size_t len)
  87 {
  88   op_t a0, a1, a2;
  89   int sh_1, sh_2;
  90   int align;
  91
  92   /* Calculate how to shift a word read at the memory operation
  93      aligned srcp to make it aligned for copy.  */
  94
  95   align = srcp % OPSIZ;
  96   sh_1 = 8 * (srcp % OPSIZ);
  97   sh_2 = 8 * OPSIZ - sh_1;
  98
  99   /* Make SRCP aligned by rounding it down to the beginning of the `op_t'
 100      it points in the middle of.  */
 101   srcp &= -OPSIZ;
 102   a0 = ((op_t *) srcp)[0];
 103
 104   if (len & 1)
 105   {
 106     a1 = ((op_t *) srcp)[1];
 107     ((op_t *) dstp)[0] = MERGE (a0, sh_1, a1, sh_2);
 108
 109     if (len == 1)
 110       return;
 111
 112     a0 = a1;
 113     srcp += OPSIZ;
 114     dstp += OPSIZ;
 115     len -= 1;
 116   }
 117
 118   fwd_align_merge (align);
 119
 120 }
 121
 122 /* _wordcopy_bwd_aligned -- Copy block finishing right before
 123    SRCP to block finishing right before DSTP with LEN `op_t' words
 124    (not LEN bytes!).  Both SRCP and DSTP should be aligned for memory
 125    operations on `op_t's.  */
 126
 127 #ifndef WORDCOPY_BWD_ALIGNED
 128 # define WORDCOPY_BWD_ALIGNED _wordcopy_bwd_aligned
 129 #endif
 130
 131 void
 132 WORDCOPY_BWD_ALIGNED (long int dstp, long int srcp, size_t len)
 133 {
 134   op_t a0, a1;
 135
 136   if (len & 1)
 137   {
 138     srcp -= OPSIZ;
 139     dstp -= OPSIZ;
 140     ((op_t *) dstp)[0] = ((op_t *) srcp)[0];
 141
 142     if (len == 1)
 143       return;
 144     len -= 1;
 145   }
 146
 147   do
 148     {
 149       srcp -= 2 * OPSIZ;
 150       dstp -= 2 * OPSIZ;
 151
 152       a1 = ((op_t *) srcp)[1];
 153       a0 = ((op_t *) srcp)[0];
 154       ((op_t *) dstp)[1] = a1;
 155       ((op_t *) dstp)[0] = a0;
 156
 157       len -= 2;
 158     }
 159   while (len != 0);
 160 }
 161
 162 #define bwd_align_merge(align)                                         \
 163   do                                                                   \
 164     {                                                                  \
 165       srcp -= 2 * OPSIZ;                                               \
 166       dstp -= 2 * OPSIZ;                                               \
 167       a1 = ((op_t *) srcp)[1];                                         \
 168       a0 = ((op_t *) srcp)[0];                                         \
 169       ((op_t *) dstp)[1] = MERGE (a1, align*8, a2, (__WORDSIZE-align*8)); \
 170       ((op_t *) dstp)[0] = MERGE (a0, align*8, a1, (__WORDSIZE-align*8)); \
 171       a2 = a0;                                                         \
 172       len -= 2;                                                                \
 173     }                                                                  \
 174   while (len != 0)
 175
 176 /* _wordcopy_bwd_dest_aligned -- Copy block finishing right
 177    before SRCP to block finishing right before DSTP with LEN `op_t'
 178    words (not LEN bytes!).  DSTP should be aligned for memory
 179    operations on `op_t', but SRCP must *not* be aligned.  */
 180
 181 #ifndef WORDCOPY_BWD_DEST_ALIGNED
 182 # define WORDCOPY_BWD_DEST_ALIGNED _wordcopy_bwd_dest_aligned
 183 #endif
 184
 185 void
 186 WORDCOPY_BWD_DEST_ALIGNED (long int dstp, long int srcp, size_t len)
 187 {
 188   op_t a0, a1, a2;
 189   int sh_1, sh_2;
 190   int align;
 191
 192   /* Calculate how to shift a word read at the memory operation
 193      aligned srcp to make it aligned for copy.  */
 194
 195   align = srcp % OPSIZ;
 196   sh_1 = 8 * (srcp % OPSIZ);
 197   sh_2 = 8 * OPSIZ - sh_1;
 198
 199   /* Make srcp aligned by rounding it down to the beginning of the op_t
 200      it points in the middle of.  */
 201   srcp &= -OPSIZ;
 202   a2 = ((op_t *) srcp)[0];
 203
 204   if (len & 1)
 205   {
 206     srcp -= OPSIZ;
 207     dstp -= OPSIZ;
 208     a1 = ((op_t *) srcp)[0];
 209     ((op_t *) dstp)[0] = MERGE (a1, sh_1, a2, sh_2);
 210
 211     if (len == 1)
 212       return;
 213
 214     a2 = a1;
 215     len -= 1;
 216   }
 217
 218   bwd_align_merge (align);
 219 }