// SPDX-License-Identifier: GPL-2.0-only/* * String functions optimized for hardware which doesn't * handle unaligned memory accesses efficiently. * * Copyright (C) 2021 Matteo Croce */#include <linux/types.h>#include <linux/module.h>/* Minimum size for a word copy to be convenient */#define BYTES_LONG sizeof(long)#define WORD_MASK (BYTES_LONG - 1)#define MIN_THRESHOLD (BYTES_LONG * 2)/* convenience union to avoid cast between different pointer types */union types { u8 *as_u8; unsigned long *as_ulong; uintptr_t as_uptr;};union const_types { const u8 *as_u8; unsigned long *as_ulong; uintptr_t as_uptr;};void *memcpy(void *dest, const void *src, size_t count){ union const_types s = { .as_u8 = src }; union types d = { .as_u8 = dest }; int distance = 0; if (count < MIN_THRESHOLD) goto copy_remainder; /* Copy a byte at time until destination is aligned. */ for (; d.as_uptr & WORD_MASK; count--) *d.as_u8++ = *s.as_u8++; distance = s.as_uptr & WORD_MASK; if (distance) { unsigned long last, next; /* * s is distance bytes ahead of d, and d just reached * the alignment boundary. Move s backward to word align it * and shift data to compensate for distance, in order to do * word-by-word copy. */ s.as_u8 -= distance; next = s.as_ulong[0]; for (; count >= BYTES_LONG; count -= BYTES_LONG) { last = next; next = s.as_ulong[1]; d.as_ulong[0] = last >> (distance * 8) | next << ((BYTES_LONG - distance) * 8); d.as_ulong++; s.as_ulong++; } /* Restore s with the original offset. */ s.as_u8 += distance; } else { /* * If the source and dest lower bits are the same, do a simple * 32/64 bit wide copy. */ for (; count >= BYTES_LONG; count -= BYTES_LONG) *d.as_ulong++ = *s.as_ulong++; }copy_remainder: while (count--) *d.as_u8++ = *s.as_u8++; return dest;}EXPORT_SYMBOL(memcpy);/* * Simply check if the buffer overlaps an call memcpy() in case, * otherwise do a simple one byte at time backward copy. */void *memmove(void *dest, const void *src, size_t count){ if (dest < src || src + count <= dest) return memcpy(dest, src, count); if (dest > src) { const char *s = src + count; char *tmp = dest + count; while (count--) *--tmp = *--s; } return dest;}EXPORT_SYMBOL(memmove);void *memset(void *s, int c, size_t count){ union types dest = { .as_u8 = s }; if (count >= MIN_THRESHOLD) { unsigned long cu = (unsigned long)c; /* Compose an ulong with 'c' repeated 4/8 times */ cu |= cu << 8; cu |= cu << 16; /* Suppress warning on 32 bit machines */ cu |= (cu << 16) << 16; for (; count && dest.as_uptr & WORD_MASK; count--) *dest.as_u8++ = c; /* Copy using the largest size allowed */ for (; count >= BYTES_LONG; count -= BYTES_LONG) *dest.as_ulong++ = cu; } /* copy the remainder */ while (count--) *dest.as_u8++ = c; return s;}EXPORT_SYMBOL(memset);
// SPDX-License-Identifier: GPL-2.0-only
/*
* String functions optimized for hardware which doesn't
* handle unaligned memory accesses efficiently.
*
* Copyright (C) 2021 Matteo Croce
*/
#include <linux/types.h>
#include <linux/module.h>
/* Minimum size for a word copy to be convenient */
#define BYTES_LONG sizeof(long)
#define WORD_MASK (BYTES_LONG - 1)
#define MIN_THRESHOLD (BYTES_LONG * 2)
/* convenience union to avoid cast between different pointer types */
union types {
u8 *as_u8;
unsigned long *as_ulong;
uintptr_t as_uptr;
};
union const_types {
const u8 *as_u8;
unsigned long *as_ulong;
uintptr_t as_uptr;
};
void *memcpy(void *dest, const void *src, size_t count)
{
union const_types s = { .as_u8 = src };
union types d = { .as_u8 = dest };
int distance = 0;
if (count < MIN_THRESHOLD)
goto copy_remainder;
/* Copy a byte at time until destination is aligned. */
for (; d.as_uptr & WORD_MASK; count--)
*d.as_u8++ = *s.as_u8++;
distance = s.as_uptr & WORD_MASK;
if (distance) {
unsigned long last, next;
/*
* s is distance bytes ahead of d, and d just reached
* the alignment boundary. Move s backward to word align it
* and shift data to compensate for distance, in order to do
* word-by-word copy.
*/
s.as_u8 -= distance;
next = s.as_ulong[0];
for (; count >= BYTES_LONG; count -= BYTES_LONG) {
last = next;
next = s.as_ulong[1];
d.as_ulong[0] = last >> (distance * 8) |
next << ((BYTES_LONG - distance) * 8);
d.as_ulong++;
s.as_ulong++;
}
/* Restore s with the original offset. */
s.as_u8 += distance;
} else {
/*
* If the source and dest lower bits are the same, do a simple
* 32/64 bit wide copy.
*/
for (; count >= BYTES_LONG; count -= BYTES_LONG)
*d.as_ulong++ = *s.as_ulong++;
}
copy_remainder:
while (count--)
*d.as_u8++ = *s.as_u8++;
return dest;
}
EXPORT_SYMBOL(memcpy);
/*
* Simply check if the buffer overlaps an call memcpy() in case,
* otherwise do a simple one byte at time backward copy.
*/
void *memmove(void *dest, const void *src, size_t count)
{
if (dest < src || src + count <= dest)
return memcpy(dest, src, count);
if (dest > src) {
const char *s = src + count;
char *tmp = dest + count;
while (count--)
*--tmp = *--s;
}
return dest;
}
EXPORT_SYMBOL(memmove);
void *memset(void *s, int c, size_t count)
{
union types dest = { .as_u8 = s };
if (count >= MIN_THRESHOLD) {
unsigned long cu = (unsigned long)c;
/* Compose an ulong with 'c' repeated 4/8 times */
cu |= cu << 8;
cu |= cu << 16;
/* Suppress warning on 32 bit machines */
cu |= (cu << 16) << 16;
for (; count && dest.as_uptr & WORD_MASK; count--)
*dest.as_u8++ = c;
/* Copy using the largest size allowed */
for (; count >= BYTES_LONG; count -= BYTES_LONG)
*dest.as_ulong++ = cu;
}
/* copy the remainder */
while (count--)
*dest.as_u8++ = c;
return s;
}
EXPORT_SYMBOL(memset);