blob: 6c66431ed93b3d4943954f0e07a04a0acf665c77 [file] [log] [blame]
Gabe Black0e499052011-11-14 14:47:18 +00001/*
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 *
Wolfgang Denkd79de1d2013-07-08 09:37:19 +02006 * SPDX-License-Identifier: GPL-2.0+
Gabe Black0e499052011-11-14 14:47:18 +00007 */
8
9/* From glibc-2.14, sysdeps/i386/memset.c */
10
Gabe Black0e499052011-11-14 14:47:18 +000011#include <linux/types.h>
Masahiro Yamadae7228522014-11-26 16:00:58 +090012#include <linux/compiler.h>
13#include <asm/string.h>
Gabe Black0e499052011-11-14 14:47:18 +000014
15typedef uint32_t op_t;
16
17void *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}
Graeme Russ1dd0b702011-12-27 22:46:39 +110072
73#define OP_T_THRES 8
74#define OPSIZ (sizeof(op_t))
75
76#define BYTE_COPY_FWD(dst_bp, src_bp, nbytes) \
77do { \
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) \
91do { \
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
105void *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}