yunque9/xcode/Libraries/libil2cpp/include/utils/MemoryUtils.h

#pragma once
#include <stdint.h>
#include "xxhash.h"

namespace il2cpp
{
namespace utils
{
    class MemoryUtils
    {
    public:
        IL2CPP_NO_INLINE inline static int MemoryCompareByteByByte(const uint8_t* left, const uint8_t* right, size_t size)
        {
            for (size_t i = 0; i < size; i++)
            {
                uint8_t leftItem = left[i];
                uint8_t rightItem = right[i];

                if (leftItem != rightItem)
                {
                    if (leftItem < rightItem)
                        return -1;

                    return 1;
                }
            }

            return 0;
        }

        inline static int MemoryCompare(const void* left, const void* right, size_t size)
        {
            const uint8_t* leftBytes = static_cast<const uint8_t*>(left);
            const uint8_t* rightBytes = static_cast<const uint8_t*>(right);
            ptrdiff_t leftUnalignedByteCount = (reinterpret_cast<intptr_t>(leftBytes + 3) & ~3) - reinterpret_cast<intptr_t>(leftBytes);
            ptrdiff_t rightUnalignedByteCount = (reinterpret_cast<intptr_t>(rightBytes + 3) & ~3) - reinterpret_cast<intptr_t>(rightBytes);

            // Memory is aligned differently, so the best we can do is byte by byte comparison
            if (leftUnalignedByteCount != rightUnalignedByteCount)
                return MemoryCompareByteByByte(leftBytes, rightBytes, size);

            // Memory is aligned at same size of 4 boundaries, but the start is not at size of 4 alignment
            // In this case, we will scan first unaligned number of bytes and then continue with scanning multiples of 4
            if (leftUnalignedByteCount != 0)
            {
                int unalignedMemoryCompare = MemoryCompareByteByByte(leftBytes, rightBytes, leftUnalignedByteCount);
                if (unalignedMemoryCompare != 0)
                    return unalignedMemoryCompare;

                leftBytes += leftUnalignedByteCount;
                rightBytes += leftUnalignedByteCount;
                size -= leftUnalignedByteCount;
            }

            size_t count4 = size / 4;
            for (size_t i = 0; i < count4; i++)
            {
                uint32_t leftItem = reinterpret_cast<const uint32_t*>(leftBytes)[i];
                uint32_t rightItem = reinterpret_cast<const uint32_t*>(rightBytes)[i];

                if (leftItem != rightItem)
                {
                    if (leftItem < rightItem)
                        return -1;

                    return 1;
                }
            }

            size_t offset = count4 * 4;
            return MemoryCompareByteByByte(leftBytes + offset, rightBytes + offset, size - offset);
        }

        inline static void* MemorySet(void* targetMemory, int value, size_t size)
        {
            uint8_t* ptr = static_cast<uint8_t*>(targetMemory);
            for (size_t i = 0; i != size; i++)
            {
                ptr[i] = static_cast<uint8_t>(value);
            }

            return targetMemory;
        }

        inline static void MemoryCopyByteByByte(uint8_t* target, const uint8_t* source, size_t size)
        {
            for (size_t i = 0; i < size; i++)
                target[i] = source[i];
        }

        inline static void* MemoryCopy(void* target, const void* source, size_t size)
        {
            uint8_t* targetBytes = static_cast<uint8_t*>(target);
            const uint8_t* sourceBytes = static_cast<const uint8_t*>(source);
            ptrdiff_t targetUnalignedByteCount = (reinterpret_cast<intptr_t>(targetBytes + 3) & ~3) - reinterpret_cast<intptr_t>(targetBytes);
            ptrdiff_t sourceUnalignedByteCount = (reinterpret_cast<intptr_t>(sourceBytes + 3) & ~3) - reinterpret_cast<intptr_t>(sourceBytes);

            // Memory is aligned differently, so the best we can do is byte by byte copy
            if (targetUnalignedByteCount != sourceUnalignedByteCount)
            {
                MemoryCopyByteByByte(targetBytes, sourceBytes, size);
                return targetBytes;
            }

            // Memory is aligned at same size of 4 boundaries, but the start is not at size of 4 alignment
            // In this case, we will copy first unaligned number of bytes and then continue with copying multiples of 4
            if (targetUnalignedByteCount != 0)
            {
                MemoryCopyByteByByte(targetBytes, sourceBytes, targetUnalignedByteCount);

                targetBytes += targetUnalignedByteCount;
                sourceBytes += targetUnalignedByteCount;
                size -= targetUnalignedByteCount;
            }

            size_t count4 = size / 4;

            const uint32_t* source32 = reinterpret_cast<const uint32_t*>(sourceBytes);
            uint32_t* target32 = reinterpret_cast<uint32_t*>(targetBytes);

            for (size_t i = 0; i < count4; i++)
                target32[i] = source32[i];

            size_t offset = count4 * 4;
            MemoryCopyByteByByte(targetBytes + offset, sourceBytes + offset, size - offset);

            return target;
        }

        template<typename T>
        static int32_t MemCmpRef(T* left, T* right)
        {
            return MemoryCompare(left, right, sizeof(T));
        }

#if IL2CPP_TINY
        template<typename T>
        static int32_t MemHashRef(T* val)
        {
            return XXH32(val, sizeof(T), 0x8f37154b);
        }

#endif
    };
#define DECL_MEMCMP_NUM(typ) template<> inline int32_t MemoryUtils::MemCmpRef<typ>(typ* left, typ* right) { return (*right > *left) ? -1 : (*right < *left) ? 1 : 0; }
    DECL_MEMCMP_NUM(int8_t)
    DECL_MEMCMP_NUM(int16_t)
    DECL_MEMCMP_NUM(int32_t)
    DECL_MEMCMP_NUM(int64_t)
    DECL_MEMCMP_NUM(uint8_t)
    DECL_MEMCMP_NUM(uint16_t)
    DECL_MEMCMP_NUM(uint32_t)
    DECL_MEMCMP_NUM(uint64_t)
    // don't think this will give the right result for NaNs and such
    DECL_MEMCMP_NUM(float)
    DECL_MEMCMP_NUM(double)
#undef DECL_MEMCMP_NUM

#define DECL_MEMHASH_NUM(typ) template<> inline int32_t MemoryUtils::MemHashRef(typ* val) { return (int32_t)(*val); }
    DECL_MEMHASH_NUM(int8_t)
    DECL_MEMHASH_NUM(int16_t)
    DECL_MEMHASH_NUM(int32_t)
    DECL_MEMHASH_NUM(uint8_t)
    DECL_MEMHASH_NUM(uint16_t)
    DECL_MEMHASH_NUM(uint32_t)
    DECL_MEMHASH_NUM(float)
#undef DECL_MEMHASH_NUM

    template<> inline int32_t MemoryUtils::MemHashRef(int64_t* val) { int64_t k = *val; return (int32_t)(k & 0xffffffff) ^ (int32_t)((k >> 32) & 0xffffffff); }
    template<> inline int32_t MemoryUtils::MemHashRef(uint64_t* val) { return MemHashRef(reinterpret_cast<int64_t*>(val)); }
    template<> inline int32_t MemoryUtils::MemHashRef(double* val) { return MemHashRef(reinterpret_cast<int64_t*>(val)); }
} // namespace utils
} // namespace il2cpp