blob: 786ba7971644543b80353d1450e6ccef7421cdff (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
FUNCTION
<<memset>>---set an area of memory, optimized for the MIPS processors
INDEX
memset
ANSI_SYNOPSIS
#include <string.h>
void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
TRAD_SYNOPSIS
#include <string.h>
void *memset(<[dst]>, <[c]>, <[length]>)
void *<[dst]>;
int <[c]>;
size_t <[length]>;
DESCRIPTION
This function converts the argument <[c]> into an unsigned
char and fills the first <[length]> characters of the array
pointed to by <[dst]> to the value.
RETURNS
<<memset>> returns the value of <[m]>.
PORTABILITY
<<memset>> is ANSI C.
<<memset>> requires no supporting OS subroutines.
QUICKREF
memset ansi pure
*/
#include <string.h>
#ifdef __mips64
#define wordtype long long
#else
#define wordtype long
#endif
#define LBLOCKSIZE (sizeof(wordtype))
#define UNALIGNED(X) ((long)(X) & (LBLOCKSIZE - 1))
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE * 4)
_PTR
_DEFUN (memset, (m, c, n),
_PTR m _AND
int c _AND
size_t n)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) || defined(__mips16)
char *s = (char *) m;
while (n-- != 0)
{
*s++ = (char) c;
}
return m;
#else
char *s = (char *) m;
int i;
unsigned wordtype buffer;
unsigned wordtype *aligned_addr;
unsigned short *short_addr;
size_t iter;
if (!TOO_SMALL (n))
{
int unaligned = UNALIGNED (s);
/* We know that N is >= LBLOCKSIZE so we can just word
align the S without having to check the length. */
if (unaligned)
{
while (unaligned++ < LBLOCKSIZE)
*s++ = (char)c, n--;
}
/* S is now word-aligned so we can process the remainder
in word sized chunks except for a few (< LBLOCKSIZE)
bytes which might be left over at the end. */
aligned_addr = (unsigned wordtype *)s;
/* Store C into each char sized location in BUFFER so that
we can set large blocks quickly. */
c &= 0xff;
buffer = c;
if (buffer != 0)
{
if (LBLOCKSIZE == 4)
{
buffer |= (buffer << 8);
buffer |= (buffer << 16);
}
else if (LBLOCKSIZE == 8)
{
buffer |= (buffer << 8);
buffer |= (buffer << 16);
buffer |= ((buffer << 31) << 1);
}
else
{
for (i = 1; i < LBLOCKSIZE; i++)
buffer = (buffer << 8) | c;
}
}
iter = n / (2*LBLOCKSIZE);
n = n % (2*LBLOCKSIZE);
while (iter > 0)
{
aligned_addr[0] = buffer;
aligned_addr[1] = buffer;
aligned_addr += 2;
iter--;
}
if (n >= LBLOCKSIZE)
{
*aligned_addr++ = buffer;
n -= LBLOCKSIZE;
}
/* Pick up the remainder with a bytewise loop. */
s = (char*)aligned_addr;
}
while (n > 0)
{
*s++ = (char)c;
n--;
}
return m;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
|
