sysdeps/i386/memcopy.h

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