(__strncat_g): Improve last patch.
[kopensolaris-gnu/glibc.git] / 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)