MIPS[64]: Implement insert.df and I8 instructions in simulator

src/mips64/simulator-mips64.cc

 // Copyright 2011 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 <limits.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #if V8_TARGET_ARCH_MIPS64
@@ skipping 4467 matching lines @@
         break;
     }
   }
   return df;
 }
 
 void Simulator::DecodeTypeMsaI8() {
   DCHECK(kArchVariant == kMips64r6);
   DCHECK(CpuFeatures::IsSupported(MIPS_SIMD));
   uint32_t opcode = instr_.InstructionBits() & kMsaI8Mask;
+  int8_t i8 = instr_.MsaImm8Value() & 0xFFu;
 
   switch (opcode) {
-    case ANDI_B:
-    case ORI_B:
-    case NORI_B:
-    case XORI_B:
-    case BMNZI_B:
-    case BMZI_B:
-    case BSELI_B:
-    case SHF_B:
-    case SHF_H:
-    case SHF_W:
-      UNIMPLEMENTED();
-      break;
+    case ANDI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = ws[i] & i8;
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case ORI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = ws[i] | i8;
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case NORI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = ~(ws[i] | i8);
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case XORI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = ws[i] ^ i8;
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case BMNZI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      get_msa_register(instr_.WdValue(), wd);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = (ws[i] & i8) | (wd[i] & ~i8);
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case BMZI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      get_msa_register(instr_.WdValue(), wd);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = (ws[i] & ~i8) | (wd[i] & i8);
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case BSELI_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      get_msa_register(instr_.WdValue(), wd);
+      for (int i = 0; i < 16; i++) {
+        wd[i] = (ws[i] & ~wd[i]) | (wd[i] & i8);
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case SHF_B: {
+      int8_t ws[16], wd[16];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 16; i++) {
+        int j = i % 4;
+        int k = (i8 >> (2 * j)) & 0x3;
+        wd[i] = ws[i - j + k];
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, BYTE);
+    } break;
+    case SHF_H: {
+      int16_t ws[8], wd[8];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 8; i++) {
+        int j = i % 4;
+        int k = (i8 >> (2 * j)) & 0x3;
+        wd[i] = ws[i - j + k];
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, HALF);
+    } break;
+    case SHF_W: {
+      int32_t ws[4], wd[4];
+      get_msa_register(instr_.WsValue(), ws);
+      for (int i = 0; i < 4; i++) {
+        int j = (i8 >> (2 * i)) & 0x3;
+        wd[i] = ws[j];
+      }
+      set_msa_register(instr_.WdValue(), wd);
+      TraceMSARegWr(wd, WORD);
+    } break;
     default:
       UNREACHABLE();
   }
 }
 
 void Simulator::DecodeTypeMsaI5() {
   DCHECK(kArchVariant == kMips64r6);
   DCHECK(CpuFeatures::IsSupported(MIPS_SIMD));
   uint32_t opcode = instr_.InstructionBits() & kMsaI5Mask;
 
@@ skipping 67 matching lines @@
           int64_t ws[2];
           get_msa_register(instr_.WsValue(), ws);
           alu_out = static_cast<int64_t>(ws[n]);
           SetResult(wd_reg(), alu_out);
           break;
         }
         default:
           UNREACHABLE();
       }
       break;
+    case INSERT:
+      switch (DecodeMsaDataFormat()) {
+        case MSA_BYTE: {
+          DCHECK(n < 16);
+          int8_t wd[16];
+          int64_t rs = get_register(instr_.WsValue());
+          get_msa_register(instr_.WdValue(), wd);
+          wd[n] = rs & 0xFFu;
+          set_msa_register(instr_.WdValue(), wd);
+          TraceMSARegWr(wd, BYTE);
+          break;
+        }
+        case MSA_HALF: {
+          DCHECK(n < 8);
+          int16_t wd[8];
+          int64_t rs = get_register(instr_.WsValue());
+          get_msa_register(instr_.WdValue(), wd);
+          wd[n] = rs & 0xFFFFu;
+          set_msa_register(instr_.WdValue(), wd);
+          TraceMSARegWr(wd, HALF);
+          break;
+        }
+        case MSA_WORD: {
+          DCHECK(n < 4);
+          int32_t wd[4];
+          int64_t rs = get_register(instr_.WsValue());
+          get_msa_register(instr_.WdValue(), wd);
+          wd[n] = rs & 0xFFFFFFFFu;
+          set_msa_register(instr_.WdValue(), wd);
+          TraceMSARegWr(wd, WORD);
+          break;
+        }
+        case MSA_DWORD: {
+          DCHECK(n < 2);
+          int64_t wd[2];
+          int64_t rs = get_register(instr_.WsValue());
+          get_msa_register(instr_.WdValue(), wd);
+          wd[n] = rs;
+          set_msa_register(instr_.WdValue(), wd);
+          TraceMSARegWr(wd, DWORD);
+          break;
+        }
+        default:
+          UNREACHABLE();
+      }
+      break;
     case SLDI:
     case SPLATI:
-    case INSERT:
     case INSVE:
       UNIMPLEMENTED();
       break;
     default:
       UNREACHABLE();
   }
 }
 
 void Simulator::DecodeTypeMsaBIT() {
   DCHECK(kArchVariant == kMips64r6);
@@ skipping 1162 matching lines @@
 }
 
 
 #undef UNSUPPORTED
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 
 #endif  // V8_TARGET_ARCH_MIPS64