sysdeps/powerpc/powerpc64/power6/wordcopy.c

   1 /* _memcopy.c -- subroutines for memory copy functions.
   2    Copyright (C) 1991, 1996 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Torbjorn Granlund (tege@sics.se).
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 /* BE VERY CAREFUL IF YOU CHANGE THIS CODE...!  */
  22
  23 #include <stddef.h>
  24 #include <memcopy.h>
  25
  26 /* _wordcopy_fwd_aligned -- Copy block beginning at SRCP to
  27    block beginning at DSTP with LEN `op_t' words (not LEN bytes!).
  28    Both SRCP and DSTP should be aligned for memory operations on `op_t's.  */
  29
  30 void
  31 _wordcopy_fwd_aligned (dstp, srcp, len)
  32      long int dstp;
  33      long int srcp;
  34      size_t len;
  35 {
  36   op_t a0, a1;
  37
  38   if (len & 1)
  39   {
  40     ((op_t *) dstp)[0] = ((op_t *) srcp)[0];
  41
  42     if (len == 1)
  43       return;
  44     srcp += OPSIZ;
  45     dstp += OPSIZ;
  46     len -= 1;
  47   }
  48
  49   do
  50     {
  51       a0 = ((op_t *) srcp)[0];
  52       a1 = ((op_t *) srcp)[1];
  53       ((op_t *) dstp)[0] = a0;
  54       ((op_t *) dstp)[1] = a1;
  55
  56       srcp += 2 * OPSIZ;
  57       dstp += 2 * OPSIZ;
  58       len -= 2;
  59     }
  60   while (len != 0);
  61 }
  62
  63 /* _wordcopy_fwd_dest_aligned -- Copy block beginning at SRCP to
  64    block beginning at DSTP with LEN `op_t' words (not LEN bytes!).
  65    DSTP should be aligned for memory operations on `op_t's, but SRCP must
  66    *not* be aligned.  */
  67
  68 void
  69 _wordcopy_fwd_dest_aligned (dstp, srcp, len)
  70      long int dstp;
  71      long int srcp;
  72      size_t len;
  73 {
  74   op_t a0, a1, a2;
  75   int sh_1, sh_2;
  76   int align;
  77
  78   /* Calculate how to shift a word read at the memory operation
  79      aligned srcp to make it aligned for copy.  */
  80
  81   align = srcp % OPSIZ;
  82   sh_1 = 8 * (srcp % OPSIZ);
  83   sh_2 = 8 * OPSIZ - sh_1;
  84
  85   /* Make SRCP aligned by rounding it down to the beginning of the `op_t'
  86      it points in the middle of.  */
  87   srcp &= -OPSIZ;
  88   a0 = ((op_t *) srcp)[0];
  89
  90   if (len & 1)
  91   {
  92     a1 = ((op_t *) srcp)[1];
  93     ((op_t *) dstp)[0] = MERGE (a0, sh_1, a1, sh_2);
  94
  95     if (len == 1)
  96       return;
  97
  98     a0 = a1;
  99     srcp += OPSIZ;
 100     dstp += OPSIZ;
 101     len -= 1;
 102   }
 103
 104   switch (align)
 105     {
 106     case 1:
 107       do
 108         {
 109           a1 = ((op_t *) srcp)[1];
 110           a2 = ((op_t *) srcp)[2];
 111           ((op_t *) dstp)[0] = MERGE (a0, 8, a1, (64-8));
 112           ((op_t *) dstp)[1] = MERGE (a1, 8, a2, (64-8));
 113           a0 = a2;
 114
 115           srcp += 2 * OPSIZ;
 116           dstp += 2 * OPSIZ;
 117           len -= 2;
 118         }
 119       while (len != 0);
 120       break;
 121     case 2:
 122       do
 123         {
 124           a1 = ((op_t *) srcp)[1];
 125           a2 = ((op_t *) srcp)[2];
 126           ((op_t *) dstp)[0] = MERGE (a0, 16, a1, (64-16));
 127           ((op_t *) dstp)[1] = MERGE (a1, 16, a2, (64-16));
 128           a0 = a2;
 129
 130           srcp += 2 * OPSIZ;
 131           dstp += 2 * OPSIZ;
 132           len -= 2;
 133         }
 134       while (len != 0);
 135       break;
 136     case 3:
 137       do
 138         {
 139           a1 = ((op_t *) srcp)[1];
 140           a2 = ((op_t *) srcp)[2];
 141           ((op_t *) dstp)[0] = MERGE (a0, 24, a1, (64-24));
 142           ((op_t *) dstp)[1] = MERGE (a1, 24, a2, (64-24));
 143           a0 = a2;
 144
 145           srcp += 2 * OPSIZ;
 146           dstp += 2 * OPSIZ;
 147           len -= 2;
 148         }
 149       while (len != 0);
 150       break;
 151     case 4:
 152       do
 153         {
 154           a1 = ((op_t *) srcp)[1];
 155           a2 = ((op_t *) srcp)[2];
 156           ((op_t *) dstp)[0] = MERGE (a0, 32, a1, (64-32));
 157           ((op_t *) dstp)[1] = MERGE (a1, 32, a2, (64-32));
 158           a0 = a2;
 159
 160           srcp += 2 * OPSIZ;
 161           dstp += 2 * OPSIZ;
 162           len -= 2;
 163         }
 164       while (len != 0);
 165       break;
 166     case 5:
 167       do
 168         {
 169           a1 = ((op_t *) srcp)[1];
 170           a2 = ((op_t *) srcp)[2];
 171           ((op_t *) dstp)[0] = MERGE (a0, 40, a1, (64-40));
 172           ((op_t *) dstp)[1] = MERGE (a1, 40, a2, (64-40));
 173           a0 = a2;
 174
 175           srcp += 2 * OPSIZ;
 176           dstp += 2 * OPSIZ;
 177           len -= 2;
 178         }
 179       while (len != 0);
 180       break;
 181     case 6:
 182       do
 183         {
 184           a1 = ((op_t *) srcp)[1];
 185           a2 = ((op_t *) srcp)[2];
 186           ((op_t *) dstp)[0] = MERGE (a0, 48, a1, (64-48));
 187           ((op_t *) dstp)[1] = MERGE (a1, 48, a2, (64-48));
 188           a0 = a2;
 189
 190           srcp += 2 * OPSIZ;
 191           dstp += 2 * OPSIZ;
 192           len -= 2;
 193         }
 194       while (len != 0);
 195       break;
 196     case 7:
 197       do
 198         {
 199           a1 = ((op_t *) srcp)[1];
 200           a2 = ((op_t *) srcp)[2];
 201           ((op_t *) dstp)[0] = MERGE (a0, 56, a1, (64-56));
 202           ((op_t *) dstp)[1] = MERGE (a1, 56, a2, (64-56));
 203           a0 = a2;
 204
 205           srcp += 2 * OPSIZ;
 206           dstp += 2 * OPSIZ;
 207           len -= 2;
 208         }
 209       while (len != 0);
 210       break;
 211     }
 212
 213 }
 214
 215 /* _wordcopy_bwd_aligned -- Copy block finishing right before
 216    SRCP to block finishing right before DSTP with LEN `op_t' words
 217    (not LEN bytes!).  Both SRCP and DSTP should be aligned for memory
 218    operations on `op_t's.  */
 219
 220 void
 221 _wordcopy_bwd_aligned (dstp, srcp, len)
 222      long int dstp;
 223      long int srcp;
 224      size_t len;
 225 {
 226   op_t a0, a1;
 227
 228   if (len & 1)
 229   {
 230     srcp -= OPSIZ;
 231     dstp -= OPSIZ;
 232     ((op_t *) dstp)[0] = ((op_t *) srcp)[0];
 233
 234     if (len == 1)
 235       return;
 236     len -= 1;
 237   }
 238
 239   do
 240     {
 241       srcp -= 2 * OPSIZ;
 242       dstp -= 2 * OPSIZ;
 243
 244       a1 = ((op_t *) srcp)[1];
 245       a0 = ((op_t *) srcp)[0];
 246       ((op_t *) dstp)[1] = a1;
 247       ((op_t *) dstp)[0] = a0;
 248
 249       len -= 2;
 250     }
 251   while (len != 0);
 252 }
 253
 254 /* _wordcopy_bwd_dest_aligned -- Copy block finishing right
 255    before SRCP to block finishing right before DSTP with LEN `op_t'
 256    words (not LEN bytes!).  DSTP should be aligned for memory
 257    operations on `op_t', but SRCP must *not* be aligned.  */
 258
 259 void
 260 _wordcopy_bwd_dest_aligned (dstp, srcp, len)
 261      long int dstp;
 262      long int srcp;
 263      size_t len;
 264 {
 265   op_t a0, a1, a2;
 266   int sh_1, sh_2;
 267   int align;
 268
 269   /* Calculate how to shift a word read at the memory operation
 270      aligned srcp to make it aligned for copy.  */
 271
 272   align = srcp % OPSIZ;
 273   sh_1 = 8 * (srcp % OPSIZ);
 274   sh_2 = 8 * OPSIZ - sh_1;
 275
 276   /* Make srcp aligned by rounding it down to the beginning of the op_t
 277      it points in the middle of.  */
 278   srcp &= -OPSIZ;
 279   a2 = ((op_t *) srcp)[0];
 280
 281   if (len & 1)
 282   {
 283     srcp -= OPSIZ;
 284     dstp -= OPSIZ;
 285     a1 = ((op_t *) srcp)[0];
 286     ((op_t *) dstp)[0] = MERGE (a1, sh_1, a2, sh_2);
 287
 288     if (len == 1)
 289       return;
 290
 291     a2 = a1;
 292     len -= 1;
 293   }
 294
 295   switch (align)
 296     {
 297     case 1:
 298       do
 299         {
 300           srcp -= 2 * OPSIZ;
 301           dstp -= 2 * OPSIZ;
 302
 303           a1 = ((op_t *) srcp)[1];
 304           a0 = ((op_t *) srcp)[0];
 305           ((op_t *) dstp)[1] = MERGE (a1, 8, a2, (64-8));
 306           ((op_t *) dstp)[0] = MERGE (a0, 8, a1, (64-8));
 307           a2 = a0;
 308
 309           len -= 2;
 310         }
 311       while (len != 0);
 312       break;
 313     case 2:
 314       do
 315         {
 316           srcp -= 2 * OPSIZ;
 317           dstp -= 2 * OPSIZ;
 318
 319           a1 = ((op_t *) srcp)[1];
 320           a0 = ((op_t *) srcp)[0];
 321           ((op_t *) dstp)[1] = MERGE (a1, 16, a2, (64-16));
 322           ((op_t *) dstp)[0] = MERGE (a0, 16, a1, (64-16));
 323           a2 = a0;
 324
 325           len -= 2;
 326         }
 327       while (len != 0);
 328       break;
 329     case 3:
 330       do
 331         {
 332           srcp -= 2 * OPSIZ;
 333           dstp -= 2 * OPSIZ;
 334
 335           a1 = ((op_t *) srcp)[1];
 336           a0 = ((op_t *) srcp)[0];
 337           ((op_t *) dstp)[1] = MERGE (a1, 24, a2, (64-24));
 338           ((op_t *) dstp)[0] = MERGE (a0, 24, a1, (64-24));
 339           a2 = a0;
 340
 341           len -= 2;
 342         }
 343       while (len != 0);
 344       break;
 345     case 4:
 346       do
 347         {
 348           srcp -= 2 * OPSIZ;
 349           dstp -= 2 * OPSIZ;
 350
 351           a1 = ((op_t *) srcp)[1];
 352           a0 = ((op_t *) srcp)[0];
 353           ((op_t *) dstp)[1] = MERGE (a1, 32, a2, (64-32));
 354           ((op_t *) dstp)[0] = MERGE (a0, 32, a1, (64-32));
 355           a2 = a0;
 356
 357           len -= 2;
 358         }
 359       while (len != 0);
 360       break;
 361     case 5:
 362       do
 363         {
 364           srcp -= 2 * OPSIZ;
 365           dstp -= 2 * OPSIZ;
 366
 367           a1 = ((op_t *) srcp)[1];
 368           a0 = ((op_t *) srcp)[0];
 369           ((op_t *) dstp)[1] = MERGE (a1, 40, a2, (64-40));
 370           ((op_t *) dstp)[0] = MERGE (a0, 40, a1, (64-40));
 371           a2 = a0;
 372
 373           len -= 2;
 374         }
 375       while (len != 0);
 376       break;
 377     case 6:
 378       do
 379         {
 380           srcp -= 2 * OPSIZ;
 381           dstp -= 2 * OPSIZ;
 382
 383           a1 = ((op_t *) srcp)[1];
 384           a0 = ((op_t *) srcp)[0];
 385           ((op_t *) dstp)[1] = MERGE (a1, 48, a2, (64-48));
 386           ((op_t *) dstp)[0] = MERGE (a0, 48, a1, (64-48));
 387           a2 = a0;
 388
 389           len -= 2;
 390         }
 391       while (len != 0);
 392       break;
 393     case 7:
 394       do
 395         {
 396           srcp -= 2 * OPSIZ;
 397           dstp -= 2 * OPSIZ;
 398
 399           a1 = ((op_t *) srcp)[1];
 400           a0 = ((op_t *) srcp)[0];
 401           ((op_t *) dstp)[1] = MERGE (a1, 56, a2, (64-56));
 402           ((op_t *) dstp)[0] = MERGE (a0, 56, a1, (64-56));
 403           a2 = a0;
 404
 405           len -= 2;
 406         }
 407       while (len != 0);
 408       break;
 409     }
 410 }