sysdeps/i386/memcopy.h

   1 /* memcopy.h -- definitions for memory copy functions.  i386 version.
   2    Copyright (C) 1991, 1997, 1998 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 #include <sysdeps/generic/memcopy.h>
  22
  23 #undef  OP_T_THRES
  24 #define OP_T_THRES      8
  25
  26 #undef  BYTE_COPY_FWD
  27 #define BYTE_COPY_FWD(dst_bp, src_bp, nbytes)                                 \
  28   do {                                                                        \
  29     int __d0;                                                                 \
  30     asm volatile(/* Clear the direction flag, so copying goes forward.  */    \
  31                  "cld\n"                                                      \
  32                  /* Copy bytes.  */                                           \
  33                  "rep\n"                                                      \
  34                  "movsb" :                                                    \
  35                  "=D" (dst_bp), "=S" (src_bp), "=c" (__d0) :                  \
  36                  "0" (dst_bp), "1" (src_bp), "2" (nbytes) :                   \
  37                  "memory");                                                   \
  38   } while (0)
  39
  40 #undef  BYTE_COPY_BWD
  41 #define BYTE_COPY_BWD(dst_ep, src_ep, nbytes)                                 \
  42   do                                                                          \
  43     {                                                                         \
  44       int __d0;                                                               \
  45       asm volatile(/* Set the direction flag, so copying goes backwards.  */  \
  46                    "std\n"                                                    \
  47                    /* Copy bytes.  */                                         \
  48                    "rep\n"                                                    \
  49                    "movsb\n"                                                  \
  50                    /* Clear the dir flag.  Convention says it should be 0. */ \
  51                    "cld" :                                                    \
  52                    "=D" (dst_ep), "=S" (src_ep), "=c" (__d0) :                \
  53                    "0" (dst_ep - 1), "1" (src_ep - 1), "2" (nbytes) :         \
  54                    "memory");                                                 \
  55       dst_ep += 1;                                                            \
  56       src_ep += 1;                                                            \
  57     } while (0)
  58
  59 #undef  WORD_COPY_FWD
  60 #define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)                    \
  61   do                                                                          \
  62     {                                                                         \
  63       int __d0;                                                               \
  64       asm volatile(/* Clear the direction flag, so copying goes forward.  */  \
  65                    "cld\n"                                                    \
  66                    /* Copy longwords.  */                                     \
  67                    "rep\n"                                                    \
  68                    "movsl" :                                                  \
  69                    "=D" (dst_bp), "=S" (src_bp), "=c" (__d0) :                \
  70                    "0" (dst_bp), "1" (src_bp), "2" ((nbytes) / 4) :           \
  71                    "memory");                                                 \
  72       (nbytes_left) = (nbytes) % 4;                                           \
  73     } while (0)
  74
  75 #undef  WORD_COPY_BWD
  76 #define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes)                    \
  77   do                                                                          \
  78     {                                                                         \
  79       int __d0;                                                               \
  80       asm volatile(/* Set the direction flag, so copying goes backwards.  */  \
  81                    "std\n"                                                    \
  82                    /* Copy longwords.  */                                     \
  83                    "rep\n"                                                    \
  84                    "movsl\n"                                                  \
  85                    /* Clear the dir flag.  Convention says it should be 0. */ \
  86                    "cld" :                                                    \
  87                    "=D" (dst_ep), "=S" (src_ep), "=c" (__d0) :                \
  88                    "0" (dst_ep - 4), "1" (src_ep - 4), "2" ((nbytes) / 4) :   \
  89                    "memory");                                                 \
  90       dst_ep += 4;                                                            \
  91       src_ep += 4;                                                            \
  92       (nbytes_left) = (nbytes) % 4;                                           \
  93     } while (0)