Updated memswap implementation

Author: sadko4u

src/main/base_backend.cpp

@@ -19,6 +19,7 @@
  * along with lsp-r3d-base-lib. If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <lsp-plug.in/common/types.h>
 #include <lsp-plug.in/r3d/base/backend.h>
 #include <lsp-plug.in/stdlib/string.h>
 
@@ -161,6 +162,52 @@ namespace lsp
 
         void base_backend_t::memswap(void *a, void *b, size_t bytes)
         {
+        #ifdef ARCH_64BIT
+            // 32-byte blocks
+            uint64_t *xa    = reinterpret_cast<uint64_t *>(a);
+            uint64_t *xb    = reinterpret_cast<uint64_t *>(b);
+
+            for (; bytes >= 32 ; bytes -= 32, xa += 4, xb += 4)
+            {
+                uint64_t t0     = xa[0];
+                uint64_t t1     = xa[1];
+                uint64_t t2     = xa[2];
+                uint64_t t3     = xa[3];
+
+                xa[0]           = xb[0];
+                xa[1]           = xb[1];
+                xa[2]           = xb[2];
+                xa[3]           = xb[3];
+
+                xb[0]           = t0;
+                xb[1]           = t1;
+                xb[2]           = t2;
+                xb[3]           = t3;
+            }
+
+            // 4-byte blocks
+            uint32_t *ya    = reinterpret_cast<uint32_t *>(xa);
+            uint32_t *yb    = reinterpret_cast<uint32_t *>(xb);
+
+            for (; bytes >= 4 ; bytes -= 4, ++ya, ++yb)
+            {
+                uint32_t t0     = ya[0];
+                ya[0]           = yb[0];
+                yb[0]           = t0;
+            }
+
+            // 1-byte blocks
+            uint8_t *za    = reinterpret_cast<uint8_t *>(ya);
+            uint8_t *zb    = reinterpret_cast<uint8_t *>(yb);
+
+            for (size_t i=0; i<bytes; ++i)
+            {
+                uint8_t t0      = za[i];
+                za[i]           = zb[i];
+                zb[i]           = t0;
+            }
+        #else
+            // 16-byte blocks
             uint32_t *xa    = reinterpret_cast<uint32_t *>(a);
             uint32_t *xb    = reinterpret_cast<uint32_t *>(b);
             for (; bytes >= 16 ; bytes -= 16, xa += 4, xb += 4)
@@ -181,13 +228,15 @@ namespace lsp
                 xb[3]           = t3;
             }
 
-            for (; bytes >= 4 ; bytes -= 4, xa += 1, xb += 1)
+            // 4-byte blocks
+            for (; bytes >= 4 ; bytes -= 4, ++xa, ++xb)
             {
                 uint32_t t0     = xa[0];
                 xa[0]           = xb[0];
                 xb[0]           = t0;
             }
 
+            // 1-byte blocks
             uint8_t *ya    = reinterpret_cast<uint8_t *>(xa);
             uint8_t *yb    = reinterpret_cast<uint8_t *>(xb);
 
@@ -197,6 +246,7 @@ namespace lsp
                 ya[i]           = yb[i];
                 yb[i]           = t0;
             }
+        #endif /* ARCH_64BIT */
         }
 
         void base_backend_t::swap_rows(void *buf, size_t rows, size_t bytes_per_row)