arch/x86/lib/string.c

   1 /*
   2  * Copyright (C) 1991,1992,1993,1997,1998,2003, 2005 Free Software Foundation, Inc.
   3  * This file is part of the GNU C Library.
   4  * Copyright (c) 2011 The Chromium OS Authors.
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 /* From glibc-2.14, sysdeps/i386/memset.c */
  10
  11 #include <compiler.h>
  12 #include <asm/string.h>
  13 #include <linux/types.h>
  14
  15 typedef uint32_t op_t;
  16
  17 void *memset(void *dstpp, int c, size_t len)
  18 {
  19         int d0;
  20         unsigned long int dstp = (unsigned long int) dstpp;
  21
  22         /* This explicit register allocation improves code very much indeed. */
  23         register op_t x asm("ax");
  24
  25         x = (unsigned char) c;
  26
  27         /* Clear the direction flag, so filling will move forward.  */
  28         asm volatile("cld");
  29
  30         /* This threshold value is optimal.  */
  31         if (len >= 12) {
  32                 /* Fill X with four copies of the char we want to fill with. */
  33                 x |= (x << 8);
  34                 x |= (x << 16);
  35
  36                 /* Adjust LEN for the bytes handled in the first loop.  */
  37                 len -= (-dstp) % sizeof(op_t);
  38
  39                 /*
  40                  * There are at least some bytes to set. No need to test for
  41                  * LEN == 0 in this alignment loop.
  42                  */
  43
  44                 /* Fill bytes until DSTP is aligned on a longword boundary. */
  45                 asm volatile(
  46                         "rep\n"
  47                         "stosb" /* %0, %2, %3 */ :
  48                         "=D" (dstp), "=c" (d0) :
  49                         "0" (dstp), "1" ((-dstp) % sizeof(op_t)), "a" (x) :
  50                         "memory");
  51
  52                 /* Fill longwords.  */
  53                 asm volatile(
  54                         "rep\n"
  55                         "stosl" /* %0, %2, %3 */ :
  56                         "=D" (dstp), "=c" (d0) :
  57                         "0" (dstp), "1" (len / sizeof(op_t)), "a" (x) :
  58                         "memory");
  59                 len %= sizeof(op_t);
  60         }
  61
  62         /* Write the last few bytes. */
  63         asm volatile(
  64                 "rep\n"
  65                 "stosb" /* %0, %2, %3 */ :
  66                 "=D" (dstp), "=c" (d0) :
  67                 "0" (dstp), "1" (len), "a" (x) :
  68                 "memory");
  69
  70         return dstpp;
  71 }
  72
  73 #define OP_T_THRES      8
  74 #define OPSIZ   (sizeof(op_t))
  75
  76 #define BYTE_COPY_FWD(dst_bp, src_bp, nbytes)                             \
  77 do {                                                                      \
  78         int __d0;                                                         \
  79         asm volatile(                                                     \
  80                 /* Clear the direction flag, so copying goes forward.  */ \
  81                 "cld\n"                                                   \
  82                 /* Copy bytes.  */                                        \
  83                 "rep\n"                                                   \
  84                 "movsb" :                                                 \
  85                 "=D" (dst_bp), "=S" (src_bp), "=c" (__d0) :               \
  86                 "0" (dst_bp), "1" (src_bp), "2" (nbytes) :                \
  87                 "memory");                                                \
  88 } while (0)
  89
  90 #define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)                \
  91 do {                                                                      \
  92         int __d0;                                                         \
  93         asm volatile(                                                     \
  94                 /* Clear the direction flag, so copying goes forward.  */ \
  95                 "cld\n"                                                   \
  96                 /* Copy longwords.  */                                    \
  97                 "rep\n"                                                   \
  98                 "movsl" :                                                 \
  99                 "=D" (dst_bp), "=S" (src_bp), "=c" (__d0) :               \
 100                 "0" (dst_bp), "1" (src_bp), "2" ((nbytes) / 4) :          \
 101                 "memory");                                                \
 102         (nbytes_left) = (nbytes) % 4;                                     \
 103 } while (0)
 104
 105 void *memcpy(void *dstpp, const void *srcpp, size_t len)
 106 {
 107         unsigned long int dstp = (long int)dstpp;
 108         unsigned long int srcp = (long int)srcpp;
 109
 110         /* Copy from the beginning to the end.  */
 111
 112         /* If there not too few bytes to copy, use word copy.  */
 113         if (len >= OP_T_THRES) {
 114                 /* Copy just a few bytes to make DSTP aligned.  */
 115                 len -= (-dstp) % OPSIZ;
 116                 BYTE_COPY_FWD(dstp, srcp, (-dstp) % OPSIZ);
 117
 118                 /* Copy from SRCP to DSTP taking advantage of the known
 119                  * alignment of DSTP.  Number of bytes remaining is put
 120                  * in the third argument, i.e. in LEN.  This number may
 121                  * vary from machine to machine.
 122                  */
 123                 WORD_COPY_FWD(dstp, srcp, len, len);
 124
 125                 /* Fall out and copy the tail.  */
 126         }
 127
 128         /* There are just a few bytes to copy. Use byte memory operations. */
 129         BYTE_COPY_FWD(dstp, srcp, len);
 130
 131         return dstpp;
 132 }