Implement remaining Boolean SIMD operations on ARM.

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 883 matching lines @@
   memcpy(value, vfp_registers_ + dreg * 2, sizeof(*value) * 2);
 }
 
 
 void Simulator::set_d_register(int dreg, const uint32_t* value) {
   DCHECK((dreg >= 0) && (dreg < DwVfpRegister::NumRegisters()));
   memcpy(vfp_registers_ + dreg * 2, value, sizeof(*value) * 2);
 }
 
 template <typename T>
+void Simulator::get_d_register(int dreg, T* value) {
+  DCHECK((dreg >= 0) && (dreg < num_d_registers));
+  memcpy(value, vfp_registers_ + dreg * 2, kDoubleSize);
+}
+
+template <typename T>
+void Simulator::set_d_register(int dreg, const T* value) {
+  DCHECK((dreg >= 0) && (dreg < num_d_registers));
+  memcpy(vfp_registers_ + dreg * 2, value, kDoubleSize);
+}
+
+template <typename T>
 void Simulator::get_q_register(int qreg, T* value) {
   DCHECK((qreg >= 0) && (qreg < num_q_registers));
   memcpy(value, vfp_registers_ + qreg * 4, kSimd128Size);
 }
 
 template <typename T>
 void Simulator::set_q_register(int qreg, const T* value) {
   DCHECK((qreg >= 0) && (qreg < num_q_registers));
   memcpy(vfp_registers_ + qreg * 4, value, kSimd128Size);
 }
 
-
 // Raw access to the PC register.
 void Simulator::set_pc(int32_t value) {
   pc_modified_ = true;
   registers_[pc] = value;
 }
 
 
 bool Simulator::has_bad_pc() const {
   return ((registers_[pc] == bad_lr) || (registers_[pc] == end_sim_pc));
 }
@@ skipping 3074 matching lines @@
 template <typename T>
 T Clamp(int64_t value) {
   static_assert(sizeof(int64_t) > sizeof(T), "T must be int32_t or smaller");
   int64_t min = static_cast<int64_t>(std::numeric_limits<T>::min());
   int64_t max = static_cast<int64_t>(std::numeric_limits<T>::max());
   int64_t clamped = std::max(min, std::min(max, value));
   return static_cast<T>(clamped);
 }
 
 template <typename T>
+T MinMax(T a, T b, bool is_min) {
+  return is_min ? std::min(a, b) : std::max(a, b);
+}
+
+template <typename T>
 void AddSaturate(Simulator* simulator, int Vd, int Vm, int Vn) {
   static const int kLanes = 16 / sizeof(T);
   T src1[kLanes], src2[kLanes];
   simulator->get_q_register(Vn, src1);
   simulator->get_q_register(Vm, src2);
   for (int i = 0; i < kLanes; i++) {
     src1[i] = Clamp<T>(Widen(src1[i]) + Widen(src2[i]));
   }
   simulator->set_q_register(Vd, src1);
 }
@@ skipping 153 matching lines @@
         case 0x6: {
           // vmin/vmax.s<size> Qd, Qm, Qn.
           NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
           bool min = instr->Bit(4) != 0;
           switch (size) {
             case Neon8: {
               int8_t src1[16], src2[16];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 16; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             case Neon16: {
               int16_t src1[8], src2[8];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 8; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             case Neon32: {
               int32_t src1[4], src2[4];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 4; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             default:
               UNREACHABLE();
               break;
           }
           break;
         }
@@ skipping 114 matching lines @@
               }
               default:
                 UNREACHABLE();
                 break;
             }
           } else {
             UNIMPLEMENTED();
           }
           break;
         }
+        case 0xa: {
+          // vpmin/vpmax.s<size> Dd, Dm, Dn.
+          NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
+          bool min = instr->Bit(4) != 0;
+          switch (size) {
+            case Neon8: {
+              int8_t dst[8], src1[8], src2[8];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              for (int i = 0; i < 4; i++) {
+                dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
+                dst[i + 4] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
+              }
+              set_d_register(Vd, dst);
+              break;
+            }
+            case Neon16: {
+              int16_t dst[4], src1[4], src2[4];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              for (int i = 0; i < 2; i++) {
+                dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
+                dst[i + 2] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
+              }
+              set_d_register(Vd, dst);
+              break;
+            }
+            case Neon32: {
+              int32_t dst[2], src1[2], src2[2];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              dst[0] = MinMax(src1[0], src1[1], min);
+              dst[1] = MinMax(src2[0], src2[1], min);
+              set_d_register(Vd, dst);
+              break;
+            }
+            default:
+              UNREACHABLE();
+              break;
+          }
+          break;
+        }
         case 0xd: {
           if (instr->Bit(4) == 0) {
             float src1[4], src2[4];
             get_q_register(Vn, src1);
             get_q_register(Vm, src2);
             for (int i = 0; i < 4; i++) {
               if (instr->Bit(21) == 0) {
                 // vadd.f32 Qd, Qm, Qn.
                 src1[i] = src1[i] + src2[i];
               } else {
@@ skipping 34 matching lines @@
                 for (int i = 0; i < 4; i++) {
                   src1[i] = 2.0f - src1[i] * src2[i];
                 }
               } else {
                 // vrsqrts.f32 Qd, Qm, Qn.
                 for (int i = 0; i < 4; i++) {
                   src1[i] = (3.0f - src1[i] * src2[i]) * 0.5f;
                 }
               }
             } else {
-              if (instr->Bit(21) == 1) {
-                // vmin.f32 Qd, Qm, Qn.
-                for (int i = 0; i < 4; i++) {
-                  src1[i] = std::min(src1[i], src2[i]);
-                }
-              } else {
-                // vmax.f32 Qd, Qm, Qn.
-                for (int i = 0; i < 4; i++) {
-                  src1[i] = std::max(src1[i], src2[i]);
-                }
+              // vmin/vmax.f32 Qd, Qm, Qn.
+              bool min = instr->Bit(21) == 1;
+              for (int i = 0; i < 4; i++) {
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
             }
             set_q_register(Vd, src1);
           } else {
             UNIMPLEMENTED();
           }
           break;
         }
         default:
           UNIMPLEMENTED();
@@ skipping 265 matching lines @@
         case 0x6: {
           // vmin/vmax.u<size> Qd, Qm, Qn.
           NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
           bool min = instr->Bit(4) != 0;
           switch (size) {
             case Neon8: {
               uint8_t src1[16], src2[16];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 16; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             case Neon16: {
               uint16_t src1[8], src2[8];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 8; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             case Neon32: {
               uint32_t src1[4], src2[4];
               get_q_register(Vn, src1);
               get_q_register(Vm, src2);
               for (int i = 0; i < 4; i++) {
-                if (min)
-                  src1[i] = std::min(src1[i], src2[i]);
-                else
-                  src1[i] = std::max(src1[i], src2[i]);
+                src1[i] = MinMax(src1[i], src2[i], min);
               }
               set_q_register(Vd, src1);
               break;
             }
             default:
               UNREACHABLE();
               break;
           }
           break;
         }
@@ skipping 70 matching lines @@
                 set_q_register(Vd, src1);
                 break;
               }
               default:
                 UNREACHABLE();
                 break;
             }
           }
           break;
         }
+        case 0xa: {
+          // vpmin/vpmax.u<size> Dd, Dm, Dn.
+          NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
+          bool min = instr->Bit(4) != 0;
+          switch (size) {
+            case Neon8: {
+              uint8_t dst[8], src1[8], src2[8];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              for (int i = 0; i < 4; i++) {
+                dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
+                dst[i + 4] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
+              }
+              set_d_register(Vd, dst);
+              break;
+            }
+            case Neon16: {
+              uint16_t dst[4], src1[4], src2[4];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              for (int i = 0; i < 2; i++) {
+                dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
+                dst[i + 2] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
+              }
+              set_d_register(Vd, dst);
+              break;
+            }
+            case Neon32: {
+              uint32_t dst[2], src1[2], src2[2];
+              get_d_register(Vn, src1);
+              get_d_register(Vm, src2);
+              dst[0] = MinMax(src1[0], src1[1], min);
+              dst[1] = MinMax(src2[0], src2[1], min);
+              set_d_register(Vd, dst);
+              break;
+            }
+            default:
+              UNREACHABLE();
+              break;
+          }
+          break;
+        }
         case 0xd: {
           if (instr->Bit(21) == 0 && instr->Bit(6) == 1 && instr->Bit(4) == 1) {
             // vmul.f32 Qd, Qn, Qm
             float src1[4], src2[4];
             get_q_register(Vn, src1);
             get_q_register(Vm, src2);
             for (int i = 0; i < 4; i++) {
               src1[i] = src1[i] * src2[i];
             }
             set_q_register(Vd, src1);
@@ skipping 1157 matching lines @@
   processor->prev_ = nullptr;
   processor->next_ = nullptr;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_ARM