libxr_mem.cpp

#include "libxr_def.hpp"
 
void LibXR::Memory::FastCopy(void* dst, const void* src, size_t size)
{
  uint8_t* d = static_cast<uint8_t*>(dst);
  const uint8_t* s = static_cast<const uint8_t*>(src);
 
  uintptr_t d_offset = reinterpret_cast<uintptr_t>(d) & (LIBXR_ALIGN_SIZE - 1);
  uintptr_t s_offset = reinterpret_cast<uintptr_t>(s) & (LIBXR_ALIGN_SIZE - 1);
 
  if (d_offset == s_offset)
  {
    if (d_offset)
    {
      size_t head = LIBXR_ALIGN_SIZE - d_offset;
      if (head > size)
      {
        head = size;
      }
      while (head--)
      {
        *d++ = *s++;
        --size;
      }
    }
 
#if LIBXR_ALIGN_SIZE == 8
    auto* dw = reinterpret_cast<uint64_t*>(d);
    auto* sw = reinterpret_cast<const uint64_t*>(s);
 
    while (size >= 64)
    {
      dw[0] = sw[0];
      dw[1] = sw[1];
      dw[2] = sw[2];
      dw[3] = sw[3];
      dw[4] = sw[4];
      dw[5] = sw[5];
      dw[6] = sw[6];
      dw[7] = sw[7];
      dw += 8;
      sw += 8;
      size -= 64;
    }
    while (size >= 8)
    {
      *dw++ = *sw++;
      size -= 8;
    }
 
    d = reinterpret_cast<uint8_t*>(dw);
    s = reinterpret_cast<const uint8_t*>(sw);
#else
    auto* dw = reinterpret_cast<uint32_t*>(d);
    auto* sw = reinterpret_cast<const uint32_t*>(s);
 
    while (size >= 32)
    {
      dw[0] = sw[0];
      dw[1] = sw[1];
      dw[2] = sw[2];
      dw[3] = sw[3];
      dw[4] = sw[4];
      dw[5] = sw[5];
      dw[6] = sw[6];
      dw[7] = sw[7];
      dw += 8;
      sw += 8;
      size -= 32;
    }
    while (size >= 4)
    {
      *dw++ = *sw++;
      size -= 4;
    }
 
    d = reinterpret_cast<uint8_t*>(dw);
    s = reinterpret_cast<const uint8_t*>(sw);
#endif
  }
  else
  {
    uintptr_t addr_diff = reinterpret_cast<uintptr_t>(s) - reinterpret_cast<uintptr_t>(d);
 
#if LIBXR_ALIGN_SIZE == 8
    if ((addr_diff & 3) == 0)
    {
      while ((reinterpret_cast<uintptr_t>(d) & 3) && size)
      {
        *d++ = *s++;
        --size;
      }
      auto* d32 = reinterpret_cast<uint32_t*>(d);
      auto* s32 = reinterpret_cast<const uint32_t*>(s);
 
      while (size >= 32)
      {
        d32[0] = s32[0];
        d32[1] = s32[1];
        d32[2] = s32[2];
        d32[3] = s32[3];
        d32[4] = s32[4];
        d32[5] = s32[5];
        d32[6] = s32[6];
        d32[7] = s32[7];
        d32 += 8;
        s32 += 8;
        size -= 32;
      }
      while (size >= 4)
      {
        *d32++ = *s32++;
        size -= 4;
      }
 
      d = reinterpret_cast<uint8_t*>(d32);
      s = reinterpret_cast<const uint8_t*>(s32);
    }
    else
#endif
        if ((addr_diff & 1) == 0)
    {
      if (reinterpret_cast<uintptr_t>(d) & 1)
      {
        *d++ = *s++;
        --size;
      }
      auto* d16 = reinterpret_cast<uint16_t*>(d);
      auto* s16 = reinterpret_cast<const uint16_t*>(s);
 
      while (size >= 16)
      {
        d16[0] = s16[0];
        d16[1] = s16[1];
        d16[2] = s16[2];
        d16[3] = s16[3];
        d16[4] = s16[4];
        d16[5] = s16[5];
        d16[6] = s16[6];
        d16[7] = s16[7];
        d16 += 8;
        s16 += 8;
        size -= 16;
      }
      while (size >= 2)
      {
        *d16++ = *s16++;
        size -= 2;
      }
 
      d = reinterpret_cast<uint8_t*>(d16);
      s = reinterpret_cast<const uint8_t*>(s16);
    }
    // Otherwise, fallback to byte-wise copying below.
  }
 
  while (size--)
  {
    *d++ = *s++;
  }
}