//----------------------------------------------------------------------------// // GNU GPL OS/K // // // // Desc: mem*() family // // // // // // Copyright © 2018-2019 The OS/K Team // // // // This file is part of OS/K. // // // // OS/K is free software: you can redistribute it and/or modify // // it under the terms of the GNU General Public License as published by // // the Free Software Foundation, either version 3 of the License, or // // any later version. // // // // OS/K is distributed in the hope that it will be useful, // // but WITHOUT ANY WARRANTY//without even the implied warranty of // // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // // GNU General Public License for more details. // // // // You should have received a copy of the GNU General Public License // // along with OS/K. If not, see . // //----------------------------------------------------------------------------// #include #include /* DO NOT compile with strict aliasing on */ //------------------------------------------// // Memory allocation // //------------------------------------------// void *malloc(size_t n) { void *ptr; error_t rc; rc = KalAllocMemory(&ptr, n, 0, 0); if (rc > 0) seterrno(rc); return ptr; } void *calloc(size_t n, size_t m) { char *mem = malloc(n * m); memzero(mem, n * m); return mem; } void free(void *ptr) { error_t rc = KalFreeMemory(ptr); (void)rc; } //------------------------------------------// // memset() family // //------------------------------------------// // // Set "bytes"-many bytes starting from ptr to val // void *memset(void *ptr, int val, size_t bytes) { uchar *uptr = (uchar *)ptr; // Deal with bytes before start of the first aligned qword while (((ulong)uptr % alignof(QWORD)) > 0 && bytes--) { *uptr++ = (uchar)val; } // At this point we're qword-aligned if (bytes > sizeof(QWORD)) { const ulong uval = ((ulong)val << 56) | ((ulong)val << 48) | ((ulong)val << 40) | ((ulong)val << 32) | ((ulong)val << 24) | ((ulong)val << 16) | ((ulong)val << 8) | ((ulong)val); ulong *uqptr = (ulong *)ptr; // Moving fast, qword by qword while (bytes > sizeof(QWORD)) { bytes -= sizeof(QWORD); *uqptr++ = uval; } uptr = (uchar *)(ulong)uqptr; } // Deal with the few remaining bytes while (bytes--) *uptr++ = (uchar)val; return ptr; } // // Set "words"-many words starting from ptr to val // void *memsetw(void *ptr, int val, size_t words) { ushort *uptr = (ushort *)ptr; // Check whether we can we do this a word-aligned way if unlikely (((ulong)uptr % alignof(WORD)) > 0) { // We can't, so we write word by word all the way up while (words--) *uptr++ = (ushort)val; return uptr; } while (((ulong)uptr % alignof(QWORD)) > 0 && words--) { *uptr++ = (ushort)val; } if (words > QWORDS_TO_WORDS(1)) { const ulong uval = ((ulong)val << 48) | ((ulong)val << 32) | ((ulong)val << 16) | ((ulong)val); ulong *uqptr = (ulong *)uptr; while (words > QWORDS_TO_WORDS(1)) { words -= QWORDS_TO_WORDS(1); *uqptr++ = uval; } uptr = (ushort *)(ulong)uqptr; } while (words--) *uptr++ = (ushort)val; return ptr; } // Set "dwords"-many dwords starting from ptr to val // XXX unimplemented void *memsetd(void *ptr, int val, size_t dwords) { (void)val; (void)dwords; seterrno(ENOSYS); return ptr; } // Set "qwords"-many qwords starting from ptr to val void *memsetq(void *ptr, long val, size_t qwords) { ulong *uptr = (ulong *)ptr; // There's no need to check for alignment while (qwords--) *uptr++ = (ulong)val; return ptr; } //------------------------------------------// // Other mem*() functions // //------------------------------------------// // // Set "bytes"-many bytes starting from ptr to 0 // void *memzero(void *ptr, size_t bytes) { return memsetb(ptr, 0, bytes); } // // Copy "bytes"-many bytes of src to dst // Does not deal with overlapping blocks (memmove's job) // void *memcpy(void *restrict dst, const void *restrict src, size_t bytes) { const ulong *usrc = (const ulong *)src; ulong *udst = (ulong *)dst; if unlikely (bytes == 0) return dst; // Can align both src and dst at once at once? if unlikely ((ulong)src % alignof(WORD) == 1 && (ulong)dst % alignof(WORD) == 1) { const uchar *ubsrc = (const uchar *)usrc; uchar *ubdst = (uchar *)udst; // Yes we can, we're guaranteed to be word-aligned after that *ubdst++ = *ubsrc++; bytes--; udst = (ulong *)ubdst; usrc = (ulong *)ubsrc; } const ushort *uwsrc = (const ushort *)usrc; ushort *uwdst = (ushort *)udst; // Align either dst or src for qword access while ((ulong)dst % alignof(QWORD) > 0 && (ulong)src % alignof(QWORD) > 0 && bytes > sizeof(WORD)) { bytes -= sizeof(WORD); *uwdst++ = *uwsrc++; } udst = (ulong *)uwdst; usrc = (ulong *)uwsrc; // Copy fast while (bytes > sizeof(QWORD)) { bytes -= sizeof(QWORD); *udst++ = *usrc++; } const uchar *ubsrc = (const uchar *)usrc; ushort *ubdst = (ushort *)udst; // Deal with the few bytes left while (bytes--) *ubdst ++ = *ubsrc++; return dst; } // // Move memory from src to dest, even if they overlap // void *memmove(void *dst, const void *src, size_t bytes) { const uchar *usrc = src; uchar *udst = dst; // Can we use memcpy() safely? if (udst < usrc) { return memcpy(dst, src, bytes); } // No, so we go backwards uchar *usrc_end = (uchar *)usrc + bytes - 1; uchar *udst_end = udst + bytes - 1; while (bytes--) *udst_end-- = *usrc_end--; return dst; } // // Compare memory areas // int memcmp(const void *ptr1, const void *ptr2, size_t bytes) { const uchar *uptr1 = ptr1; const uchar *uptr2 = ptr2; while (bytes--) { if (*uptr1++ != *uptr2++) { return uptr1[-1] < uptr2[-1] ? -1 : 1; } } return 0; }