[ARM] Implement D-register versions of vzip, vuzp, and vtrn.

src/arm/simulator-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #if V8_TARGET_ARCH_ARM
 
@@ skipping 5064 matching lines @@
               uint64_t table;
               get_d_register(vn + index / kDoubleSize, &table);
               result |=
                   ((table >> ((index % kDoubleSize) * kBitsPerByte)) & 0xFF)
                   << shift;
             } else if (vtbx) {
               result |= destination & (0xFFull << shift);
             }
           }
           set_d_register(vd, &result);
-        } else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 8) == 0x1 &&
-                   instr->Bit(6) == 1) {
+        } else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 8) == 0x1) {
           NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
-          int Vd = instr->VFPDRegValue(kSimd128Precision);
-          int Vm = instr->VFPMRegValue(kSimd128Precision);
-          if (instr->Bit(7) == 1) {
-            // vzip.<size> Qd, Qm.
-            switch (size) {
-              case Neon8: {
-                uint8_t src1[16], src2[16], dst1[16], dst2[16];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 8; i++) {
-                  dst1[i * 2] = src1[i];
-                  dst1[i * 2 + 1] = src2[i];
-                  dst2[i * 2] = src1[i + 8];
-                  dst2[i * 2 + 1] = src2[i + 8];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              case Neon16: {
-                uint16_t src1[8], src2[8], dst1[8], dst2[8];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 4; i++) {
-                  dst1[i * 2] = src1[i];
-                  dst1[i * 2 + 1] = src2[i];
-                  dst2[i * 2] = src1[i + 4];
-                  dst2[i * 2 + 1] = src2[i + 4];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              case Neon32: {
-                uint32_t src1[4], src2[4], dst1[4], dst2[4];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 2; i++) {
-                  dst1[i * 2] = src1[i];
-                  dst1[i * 2 + 1] = src2[i];
-                  dst2[i * 2] = src1[i + 2];
-                  dst2[i * 2 + 1] = src2[i + 2];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              default:
-                UNREACHABLE();
-                break;
+          if (instr->Bit(6) == 0) {
+            int Vd = instr->VFPDRegValue(kDoublePrecision);
+            int Vm = instr->VFPMRegValue(kDoublePrecision);
+            if (instr->Bit(7) == 1) {
+              // vzip.<size> Dd, Dm.
+              switch (size) {
+                case Neon8: {

[martyn.capewell, 2017/04/06 13:09:49]

It would be good to factorise the zip and uzp operations into two functions
templated on the element type and register, so you can write something like this
for zip:

int s = sizeof(R) / (2 * sizeof(E));
for (int i = 0; i < s; i++) {
  dst1[i * 2] = src1[i];
  dst1[i * 2 + 1] = src2[i];
  dst2[i * 2] = src1[i + s];
  dst2[i * 2 + 1] = src1[i + s];
}

[bbudge, 2017/04/06 17:49:43]

Done.

I rewrote the get_ and set_q_register templates to accept a size, so more of the
repetitive code could be templatized, then templatized as many existing
functions in the simulator as made sense, including the vzip, vuzp, and vtrn
operations.

The new methods are get_ and set_neon_register.

+                  uint8_t src1[8], src2[8], dst1[8], dst2[8];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  for (int i = 0; i < 4; i++) {
+                    dst1[i * 2] = src1[i];
+                    dst1[i * 2 + 1] = src2[i];
+                    dst2[i * 2] = src1[i + 4];
+                    dst2[i * 2 + 1] = src2[i + 4];
+                  }
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                case Neon16: {
+                  uint16_t src1[4], src2[4], dst1[4], dst2[4];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  for (int i = 0; i < 2; i++) {
+                    dst1[i * 2] = src1[i];
+                    dst1[i * 2 + 1] = src2[i];
+                    dst2[i * 2] = src1[i + 2];
+                    dst2[i * 2 + 1] = src2[i + 2];
+                  }
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                case Neon32: {
+                  uint32_t src1[2], src2[2], dst1[2], dst2[2];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  dst1[0] = src1[0];
+                  dst1[1] = src2[0];
+                  dst2[0] = src1[1];
+                  dst2[1] = src2[1];
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                default:
+                  UNREACHABLE();
+                  break;
+              }
+            } else {
+              // vuzp.<size> Dd, Dm.
+              switch (size) {
+                case Neon8: {
+                  uint8_t src1[8], src2[8], dst1[8], dst2[8];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  for (int i = 0; i < 4; i++) {
+                    dst1[i] = src1[i * 2];
+                    dst1[i + 4] = src2[i * 2];
+                    dst2[i] = src1[i * 2 + 1];
+                    dst2[i + 4] = src2[i * 2 + 1];
+                  }
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                case Neon16: {
+                  uint16_t src1[4], src2[4], dst1[4], dst2[4];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  for (int i = 0; i < 2; i++) {
+                    dst1[i] = src1[i * 2];
+                    dst1[i + 2] = src2[i * 2];
+                    dst2[i] = src1[i * 2 + 1];
+                    dst2[i + 2] = src2[i * 2 + 1];
+                  }
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                case Neon32: {
+                  uint32_t src1[2], src2[2], dst1[2], dst2[2];
+                  get_d_register(Vd, src1);
+                  get_d_register(Vm, src2);
+                  dst1[0] = src1[0];
+                  dst1[1] = src2[0];
+                  dst2[0] = src1[1];
+                  dst2[1] = src2[1];
+                  set_d_register(Vd, dst1);
+                  set_d_register(Vm, dst2);
+                  break;
+                }
+                default:
+                  UNREACHABLE();
+                  break;
+              }
             }
           } else {
-            // vuzp.<size> Qd, Qm.
-            switch (size) {
-              case Neon8: {
-                uint8_t src1[16], src2[16], dst1[16], dst2[16];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 8; i++) {
-                  dst1[i] = src1[i * 2];
-                  dst1[i + 8] = src2[i * 2];
-                  dst2[i] = src1[i * 2 + 1];
-                  dst2[i + 8] = src2[i * 2 + 1];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              case Neon16: {
-                uint16_t src1[8], src2[8], dst1[8], dst2[8];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 4; i++) {
-                  dst1[i] = src1[i * 2];
-                  dst1[i + 4] = src2[i * 2];
-                  dst2[i] = src1[i * 2 + 1];
-                  dst2[i + 4] = src2[i * 2 + 1];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              case Neon32: {
-                uint32_t src1[4], src2[4], dst1[4], dst2[4];
-                get_q_register(Vd, src1);
-                get_q_register(Vm, src2);
-                for (int i = 0; i < 2; i++) {
-                  dst1[i] = src1[i * 2];
-                  dst1[i + 2] = src2[i * 2];
-                  dst2[i] = src1[i * 2 + 1];
-                  dst2[i + 2] = src2[i * 2 + 1];
-                }
-                set_q_register(Vd, dst1);
-                set_q_register(Vm, dst2);
-                break;
-              }
-              default:
-                UNREACHABLE();
-                break;
+            int Vd = instr->VFPDRegValue(kSimd128Precision);
+            int Vm = instr->VFPMRegValue(kSimd128Precision);
+            if (instr->Bit(7) == 1) {
+              // vzip.<size> Qd, Qm.
+              switch (size) {
+                case Neon8: {
+                  uint8_t src1[16], src2[16], dst1[16], dst2[16];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 8; i++) {
+                    dst1[i * 2] = src1[i];
+                    dst1[i * 2 + 1] = src2[i];
+                    dst2[i * 2] = src1[i + 8];
+                    dst2[i * 2 + 1] = src2[i + 8];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                case Neon16: {
+                  uint16_t src1[8], src2[8], dst1[8], dst2[8];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 4; i++) {
+                    dst1[i * 2] = src1[i];
+                    dst1[i * 2 + 1] = src2[i];
+                    dst2[i * 2] = src1[i + 4];
+                    dst2[i * 2 + 1] = src2[i + 4];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                case Neon32: {
+                  uint32_t src1[4], src2[4], dst1[4], dst2[4];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 2; i++) {
+                    dst1[i * 2] = src1[i];
+                    dst1[i * 2 + 1] = src2[i];
+                    dst2[i * 2] = src1[i + 2];
+                    dst2[i * 2 + 1] = src2[i + 2];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                default:
+                  UNREACHABLE();
+                  break;
+              }
+            } else {
+              // vuzp.<size> Qd, Qm.
+              switch (size) {
+                case Neon8: {
+                  uint8_t src1[16], src2[16], dst1[16], dst2[16];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 8; i++) {
+                    dst1[i] = src1[i * 2];
+                    dst1[i + 8] = src2[i * 2];
+                    dst2[i] = src1[i * 2 + 1];
+                    dst2[i + 8] = src2[i * 2 + 1];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                case Neon16: {
+                  uint16_t src1[8], src2[8], dst1[8], dst2[8];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 4; i++) {
+                    dst1[i] = src1[i * 2];
+                    dst1[i + 4] = src2[i * 2];
+                    dst2[i] = src1[i * 2 + 1];
+                    dst2[i + 4] = src2[i * 2 + 1];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                case Neon32: {
+                  uint32_t src1[4], src2[4], dst1[4], dst2[4];
+                  get_q_register(Vd, src1);
+                  get_q_register(Vm, src2);
+                  for (int i = 0; i < 2; i++) {
+                    dst1[i] = src1[i * 2];
+                    dst1[i + 2] = src2[i * 2];
+                    dst2[i] = src1[i * 2 + 1];
+                    dst2[i + 2] = src2[i * 2 + 1];
+                  }
+                  set_q_register(Vd, dst1);
+                  set_q_register(Vm, dst2);
+                  break;
+                }
+                default:
+                  UNREACHABLE();
+                  break;
+              }
             }
           }
         } else if (instr->Bits(17, 16) == 0 && instr->Bits(11, 9) == 0) {
           // vrev<op>.size Qd, Qm
           int Vd = instr->VFPDRegValue(kSimd128Precision);
           int Vm = instr->VFPMRegValue(kSimd128Precision);
           NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
           NeonSize op = static_cast<NeonSize>(static_cast<int>(Neon64) -
                                               instr->Bits(8, 7));
           switch (op) {
@@ skipping 67 matching lines @@
                 default:
                   UNREACHABLE();
                   break;
               }
               break;
             }
             default:
               UNREACHABLE();
               break;
           }
-        } else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 6) == 0x3) {
-          int Vd = instr->VFPDRegValue(kSimd128Precision);
-          int Vm = instr->VFPMRegValue(kSimd128Precision);
+        } else if (instr->Bits(17, 16) == 0x2 && instr->Bits(11, 7) == 0x1) {
           NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
-          // vtrn.<size> Qd, Qm.
-          switch (size) {
-            case Neon8: {
-              uint8_t src[16], dst[16];
-              get_q_register(Vd, dst);
-              get_q_register(Vm, src);
-              for (int i = 0; i < 8; i++) {
-                std::swap(dst[2 * i + 1], src[2 * i]);
+          if (instr->Bit(6) == 0) {
+            int Vd = instr->VFPDRegValue(kDoublePrecision);
+            int Vm = instr->VFPMRegValue(kDoublePrecision);
+            // vtrn.<size> Dd, Dm.
+            switch (size) {
+              case Neon8: {
+                uint8_t src[8], dst[8];
+                get_d_register(Vd, dst);
+                get_d_register(Vm, src);
+                for (int i = 0; i < 4; i++) {
+                  std::swap(dst[2 * i + 1], src[2 * i]);
+                }
+                set_d_register(Vd, dst);
+                set_d_register(Vm, src);
+                break;
               }
-              set_q_register(Vd, dst);
-              set_q_register(Vm, src);
-              break;
+              case Neon16: {
+                uint16_t src[4], dst[4];
+                get_d_register(Vd, dst);
+                get_d_register(Vm, src);
+                for (int i = 0; i < 2; i++) {
+                  std::swap(dst[2 * i + 1], src[2 * i]);
+                }
+                set_d_register(Vd, dst);
+                set_d_register(Vm, src);
+                break;
+              }
+              case Neon32: {
+                uint32_t src[2], dst[2];
+                get_d_register(Vd, dst);
+                get_d_register(Vm, src);
+                std::swap(dst[1], src[0]);
+                set_d_register(Vd, dst);
+                set_d_register(Vm, src);
+                break;
+              }
+              default:
+                UNREACHABLE();
+                break;
             }
-            case Neon16: {
-              uint16_t src[8], dst[8];
-              get_q_register(Vd, dst);
-              get_q_register(Vm, src);
-              for (int i = 0; i < 4; i++) {
-                std::swap(dst[2 * i + 1], src[2 * i]);
+          } else {
+            int Vd = instr->VFPDRegValue(kSimd128Precision);
+            int Vm = instr->VFPMRegValue(kSimd128Precision);
+            // vtrn.<size> Qd, Qm.
+            switch (size) {
+              case Neon8: {
+                uint8_t src[16], dst[16];
+                get_q_register(Vd, dst);
+                get_q_register(Vm, src);
+                for (int i = 0; i < 8; i++) {
+                  std::swap(dst[2 * i + 1], src[2 * i]);
+                }
+                set_q_register(Vd, dst);
+                set_q_register(Vm, src);
+                break;
               }
-              set_q_register(Vd, dst);
-              set_q_register(Vm, src);
-              break;
+              case Neon16: {
+                uint16_t src[8], dst[8];
+                get_q_register(Vd, dst);
+                get_q_register(Vm, src);
+                for (int i = 0; i < 4; i++) {
+                  std::swap(dst[2 * i + 1], src[2 * i]);
+                }
+                set_q_register(Vd, dst);
+                set_q_register(Vm, src);
+                break;
+              }
+              case Neon32: {
+                uint32_t src[4], dst[4];
+                get_q_register(Vd, dst);
+                get_q_register(Vm, src);
+                for (int i = 0; i < 2; i++) {
+                  std::swap(dst[2 * i + 1], src[2 * i]);
+                }
+                set_q_register(Vd, dst);
+                set_q_register(Vm, src);
+                break;
+              }
+              default:
+                UNREACHABLE();
+                break;
             }
-            case Neon32: {
-              uint32_t src[4], dst[4];
-              get_q_register(Vd, dst);
-              get_q_register(Vm, src);
-              for (int i = 0; i < 2; i++) {
-                std::swap(dst[2 * i + 1], src[2 * i]);
-              }
-              set_q_register(Vd, dst);
-              set_q_register(Vm, src);
-              break;
-            }
-            default:
-              UNREACHABLE();
-              break;
           }
         } else if (instr->Bits(17, 16) == 0x1 && instr->Bit(11) == 0) {
           int Vd = instr->VFPDRegValue(kSimd128Precision);
           int Vm = instr->VFPMRegValue(kSimd128Precision);
           NeonSize size = static_cast<NeonSize>(instr->Bits(19, 18));
           if (instr->Bits(9, 6) == 0xd) {
             // vabs<type>.<size> Qd, Qm
             if (instr->Bit(10) != 0) {
               // floating point (clear sign bits)
               uint32_t src[4];
@@ skipping 896 matching lines @@
   processor->prev_ = nullptr;
   processor->next_ = nullptr;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM