/*
|
/*
|
FUNCTION
|
FUNCTION
|
<<memset>>---set an area of memory, optimized for the MIPS processors
|
<<memset>>---set an area of memory, optimized for the MIPS processors
|
|
|
INDEX
|
INDEX
|
memset
|
memset
|
|
|
ANSI_SYNOPSIS
|
ANSI_SYNOPSIS
|
#include <string.h>
|
#include <string.h>
|
void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
|
void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
|
|
|
TRAD_SYNOPSIS
|
TRAD_SYNOPSIS
|
#include <string.h>
|
#include <string.h>
|
void *memset(<[dst]>, <[c]>, <[length]>)
|
void *memset(<[dst]>, <[c]>, <[length]>)
|
void *<[dst]>;
|
void *<[dst]>;
|
int <[c]>;
|
int <[c]>;
|
size_t <[length]>;
|
size_t <[length]>;
|
|
|
DESCRIPTION
|
DESCRIPTION
|
This function converts the argument <[c]> into an unsigned
|
This function converts the argument <[c]> into an unsigned
|
char and fills the first <[length]> characters of the array
|
char and fills the first <[length]> characters of the array
|
pointed to by <[dst]> to the value.
|
pointed to by <[dst]> to the value.
|
|
|
RETURNS
|
RETURNS
|
<<memset>> returns the value of <[m]>.
|
<<memset>> returns the value of <[m]>.
|
|
|
PORTABILITY
|
PORTABILITY
|
<<memset>> is ANSI C.
|
<<memset>> is ANSI C.
|
|
|
<<memset>> requires no supporting OS subroutines.
|
<<memset>> requires no supporting OS subroutines.
|
|
|
QUICKREF
|
QUICKREF
|
memset ansi pure
|
memset ansi pure
|
*/
|
*/
|
|
|
#include <string.h>
|
#include <string.h>
|
|
|
#ifdef __mips64
|
#ifdef __mips64
|
#define wordtype long long
|
#define wordtype long long
|
#else
|
#else
|
#define wordtype long
|
#define wordtype long
|
#endif
|
#endif
|
|
|
#define LBLOCKSIZE (sizeof(wordtype))
|
#define LBLOCKSIZE (sizeof(wordtype))
|
#define UNALIGNED(X) ((long)(X) & (LBLOCKSIZE - 1))
|
#define UNALIGNED(X) ((long)(X) & (LBLOCKSIZE - 1))
|
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE * 4)
|
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE * 4)
|
|
|
_PTR
|
_PTR
|
_DEFUN (memset, (m, c, n),
|
_DEFUN (memset, (m, c, n),
|
_PTR m _AND
|
_PTR m _AND
|
int c _AND
|
int c _AND
|
size_t n)
|
size_t n)
|
{
|
{
|
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) || defined(__mips16)
|
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__) || defined(__mips16)
|
char *s = (char *) m;
|
char *s = (char *) m;
|
|
|
while (n-- != 0)
|
while (n-- != 0)
|
{
|
{
|
*s++ = (char) c;
|
*s++ = (char) c;
|
}
|
}
|
|
|
return m;
|
return m;
|
#else
|
#else
|
char *s = (char *) m;
|
char *s = (char *) m;
|
int i;
|
int i;
|
unsigned wordtype buffer;
|
unsigned wordtype buffer;
|
unsigned wordtype *aligned_addr;
|
unsigned wordtype *aligned_addr;
|
unsigned short *short_addr;
|
unsigned short *short_addr;
|
size_t iter;
|
size_t iter;
|
|
|
if (!TOO_SMALL (n))
|
if (!TOO_SMALL (n))
|
{
|
{
|
int unaligned = UNALIGNED (s);
|
int unaligned = UNALIGNED (s);
|
|
|
/* We know that N is >= LBLOCKSIZE so we can just word
|
/* We know that N is >= LBLOCKSIZE so we can just word
|
align the S without having to check the length. */
|
align the S without having to check the length. */
|
|
|
if (unaligned)
|
if (unaligned)
|
{
|
{
|
while (unaligned++ < LBLOCKSIZE)
|
while (unaligned++ < LBLOCKSIZE)
|
*s++ = (char)c, n--;
|
*s++ = (char)c, n--;
|
}
|
}
|
|
|
/* S is now word-aligned so we can process the remainder
|
/* S is now word-aligned so we can process the remainder
|
in word sized chunks except for a few (< LBLOCKSIZE)
|
in word sized chunks except for a few (< LBLOCKSIZE)
|
bytes which might be left over at the end. */
|
bytes which might be left over at the end. */
|
|
|
aligned_addr = (unsigned wordtype *)s;
|
aligned_addr = (unsigned wordtype *)s;
|
|
|
/* Store C into each char sized location in BUFFER so that
|
/* Store C into each char sized location in BUFFER so that
|
we can set large blocks quickly. */
|
we can set large blocks quickly. */
|
c &= 0xff;
|
c &= 0xff;
|
buffer = c;
|
buffer = c;
|
if (buffer != 0)
|
if (buffer != 0)
|
{
|
{
|
if (LBLOCKSIZE == 4)
|
if (LBLOCKSIZE == 4)
|
{
|
{
|
buffer |= (buffer << 8);
|
buffer |= (buffer << 8);
|
buffer |= (buffer << 16);
|
buffer |= (buffer << 16);
|
}
|
}
|
else if (LBLOCKSIZE == 8)
|
else if (LBLOCKSIZE == 8)
|
{
|
{
|
buffer |= (buffer << 8);
|
buffer |= (buffer << 8);
|
buffer |= (buffer << 16);
|
buffer |= (buffer << 16);
|
buffer |= ((buffer << 31) << 1);
|
buffer |= ((buffer << 31) << 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
for (i = 1; i < LBLOCKSIZE; i++)
|
for (i = 1; i < LBLOCKSIZE; i++)
|
buffer = (buffer << 8) | c;
|
buffer = (buffer << 8) | c;
|
}
|
}
|
}
|
}
|
|
|
iter = n / (2*LBLOCKSIZE);
|
iter = n / (2*LBLOCKSIZE);
|
n = n % (2*LBLOCKSIZE);
|
n = n % (2*LBLOCKSIZE);
|
while (iter > 0)
|
while (iter > 0)
|
{
|
{
|
aligned_addr[0] = buffer;
|
aligned_addr[0] = buffer;
|
aligned_addr[1] = buffer;
|
aligned_addr[1] = buffer;
|
aligned_addr += 2;
|
aligned_addr += 2;
|
iter--;
|
iter--;
|
}
|
}
|
|
|
if (n >= LBLOCKSIZE)
|
if (n >= LBLOCKSIZE)
|
{
|
{
|
*aligned_addr++ = buffer;
|
*aligned_addr++ = buffer;
|
n -= LBLOCKSIZE;
|
n -= LBLOCKSIZE;
|
}
|
}
|
|
|
/* Pick up the remainder with a bytewise loop. */
|
/* Pick up the remainder with a bytewise loop. */
|
s = (char*)aligned_addr;
|
s = (char*)aligned_addr;
|
}
|
}
|
|
|
while (n > 0)
|
while (n > 0)
|
{
|
{
|
*s++ = (char)c;
|
*s++ = (char)c;
|
n--;
|
n--;
|
}
|
}
|
|
|
return m;
|
return m;
|
#endif /* not PREFER_SIZE_OVER_SPEED */
|
#endif /* not PREFER_SIZE_OVER_SPEED */
|
}
|
}
|
|
|
