memoryIO.cpp

Go to the documentation of this file.

 
#include <memory/memoryIO.h>
 
using namespace MaxOS::memory;
 
MemIO::MemIO(uintptr_t address)
: m_address(address)
{
 
}
 
MemIO::~MemIO() = default;
 
MemIO8Bit::MemIO8Bit(uintptr_t address)
: MemIO(address)
{
}
 
MemIO8Bit::~MemIO8Bit() = default;
 
void MemIO8Bit::write(uint8_t data) {
 
    (*((volatile uint8_t*) (m_address))) = (data);
}
 
uint8_t MemIO8Bit::read() {
 
    return *((volatile uint8_t*) (m_address));
}
 
MemIO16Bit::MemIO16Bit(uintptr_t address)
: MemIO(address)
{
}
 
MemIO16Bit::~MemIO16Bit() = default;
 
void MemIO16Bit::write(uint16_t data) {
 
    (*((volatile uint16_t*) (m_address))) = (data);
}
 
uint16_t MemIO16Bit::read() {
 
    return *((volatile uint16_t*) (m_address));
}
 
MemIO32Bit::MemIO32Bit(uintptr_t address)
: MemIO(address)
{
}
 
MemIO32Bit::~MemIO32Bit() = default;
 
void MemIO32Bit::write(uint32_t data) {
 
    (*((volatile uint32_t*) (m_address))) = (data);
}
 
uint32_t MemIO32Bit::read() {
 
    return *((volatile uint32_t*) (m_address));
}
 
MemIO64Bit::MemIO64Bit(uintptr_t address)
: MemIO(address)
{
}
 
MemIO64Bit::~MemIO64Bit() = default;
 
void MemIO64Bit::write(uint64_t data) {
 
    (*((volatile uint64_t*) (m_address))) = (data);
}
 
uint64_t MemIO64Bit::read() {
 
    return *((volatile uint64_t*) (m_address));
}
 
 
void* memcpy(void* destination, const void* source, uint64_t num) {
 
    // Make sure the source and destination are not the same
    if (destination == source)
        return destination;
 
    // Make sure they exist
    if (destination == nullptr || source == nullptr)
        return destination;
 
    // Get the source and destination
    auto* dst = (unsigned char*) destination;
    const auto* src = (const unsigned char*) source;
 
    // Copy the data
    for (size_t i = 0; i < num; i++)
        dst[i] = src[i];
 
    // Usefully for easier code writing
    return destination;
}
 
void* memset(void* ptr, unsigned char value, uint64_t num) {
 
    // Make sure the pointer exists
    if (ptr == nullptr)
        return ptr;
 
    auto* dst = (unsigned char*) ptr;
    for (size_t i = 0; i < num; i++)
        dst[i] = (unsigned char) value;
    return ptr;
}
 
void* memset(void* ptr, uint32_t value, uint64_t num) {
 
    // Make sure the pointer exists
    if (ptr == nullptr)
        return ptr;
 
    auto* dst = (uint32_t*) ptr;
    for (size_t i = 0; i < num; i++)
        dst[i] = value;
    return ptr;
}
 
void* memmove(void* destination, const void* source, uint64_t num) {
 
    // Make sure the source and destination are not the same
    if (destination == source)
        return destination;
 
    // Make sure they exist
    if (destination == nullptr || source == nullptr)
        return destination;
 
    auto* dst = (unsigned char*) destination;
    const auto* src = (const unsigned char*) source;
    if (dst < src) {
        for (size_t i = 0; i < num; i++)
            dst[i] = src[i];
    } else {
        for (size_t i = num; i != 0; i--)
            dst[i - 1] = src[i - 1];
    }
    return destination;
}
 
int memcmp(const void* ptr1, const void* ptr2, uint64_t num) {
 
    // Make sure the pointers exist
    if (ptr1 == nullptr || ptr2 == nullptr)
        return 0;
 
    const auto* p1 = (const unsigned char*) ptr1;
    const auto* p2 = (const unsigned char*) ptr2;
    for (size_t i = 0; i < num; i++) {
        if (p1[i] < p2[i])
            return -1;
        if (p1[i] > p2[i])
            return 1;
    }
    return 0;
}