[compiler] [wasm] Introduce Word32/64ReverseBytes as TF Optional Opcode

src/s390/simulator-s390.cc

 // Copyright 2014 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_S390
 
@@ skipping 1730 matching lines @@
   registers_[3] = 0x50Bad4U;
   registers_[12] = 0x50Bad4U;
 #endif
 }
 
 uint32_t Simulator::ReadWU(intptr_t addr, Instruction* instr) {
   uint32_t* ptr = reinterpret_cast<uint32_t*>(addr);
   return *ptr;
 }
 
+int64_t Simulator::ReadW64(intptr_t addr, Instruction* instr) {
+  int64_t* ptr = reinterpret_cast<int64_t*>(addr);
+  return *ptr;
+}
+
 int32_t Simulator::ReadW(intptr_t addr, Instruction* instr) {
   int32_t* ptr = reinterpret_cast<int32_t*>(addr);
   return *ptr;
 }
 
 void Simulator::WriteW(intptr_t addr, uint32_t value, Instruction* instr) {
   uint32_t* ptr = reinterpret_cast<uint32_t*>(addr);
   *ptr = value;
   return;
 }
@@ skipping 3745 matching lines @@
       break;
     }
     default:
       UNREACHABLE();
       return false;
   }
   return true;
 }
 
 int16_t Simulator::ByteReverse(int16_t hword) {
+#if defined(__GNUC__)
+  return __builtin_bswap16(hword);
+#else
   return (hword << 8) | ((hword >> 8) & 0x00ff);
+#endif
 }
 
 int32_t Simulator::ByteReverse(int32_t word) {
+#if defined(__GNUC__)
+  return __builtin_bswap32(word);
+#else
   int32_t result = word << 24;
   result |= (word << 8) & 0x00ff0000;
   result |= (word >> 8) & 0x0000ff00;
   result |= (word >> 24) & 0x00000ff;
   return result;
+#endif
+}
+
+int64_t Simulator::ByteReverse(int64_t dword) {
+#if defined(__GNUC__)
+  return __builtin_bswap64(dword);
+#else
+#error unsupport __builtin_bswap64
+#endif
 }
 
 int Simulator::DecodeInstructionOriginal(Instruction* instr) {
   int instrLength = instr->InstructionLength();
   bool processed = true;
   if (instrLength == 2)
     processed = DecodeTwoByte(instr);
   else if (instrLength == 4)
     processed = DecodeFourByte(instr);
   else if (instrLength == 6)
@@ skipping 4280 matching lines @@
   DCHECK(r1 % 2 == 0);
 
   int64_t dividend = get_register(r1 + 1);
   int64_t divisor = get_register(r2);
   set_register(r1, dividend % divisor);
   set_register(r1 + 1, dividend / divisor);
   return length;
 }
 
 EVALUATE(LRVGR) {
-  UNIMPLEMENTED();
-  USE(instr);
-  return 0;
+  DCHECK_OPCODE(LRVGR);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int64_t r2_val = get_register(r2);
+  int64_t r1_val = ByteReverse(r2_val);
+
+  set_register(r1, r1_val);
+  return length;
 }
 
 EVALUATE(LPGFR) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
 EVALUATE(LNGFR) {
   UNIMPLEMENTED();
@@ skipping 92 matching lines @@
   return 0;
 }
 
 EVALUATE(KMAC) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
 EVALUATE(LRVR) {
-  UNIMPLEMENTED();
-  USE(instr);
-  return 0;
+  DCHECK_OPCODE(LRVR);
+  DECODE_RRE_INSTRUCTION(r1, r2);
+  int32_t r2_val = get_low_register<int32_t>(r2);
+  int32_t r1_val = ByteReverse(r2_val);
+
+  set_low_register(r1, r1_val);
+  return length;
 }
 
 EVALUATE(CGR) {
   DCHECK_OPCODE(CGR);
   DECODE_RRE_INSTRUCTION(r1, r2);
   // Compare (64)
   int64_t r1_val = get_register(r1);
   int64_t r2_val = get_register(r2);
   SetS390ConditionCode<int64_t>(r1_val, r2_val);
   return length;
@@ skipping 778 matching lines @@
   USE(instr);
   return 0;
 }
 
 EVALUATE(CVBG) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
-EVALUATE(LRVG) {
-  UNIMPLEMENTED();
-  USE(instr);
-  return 0;
-}
-
 EVALUATE(LT) {
   DCHECK_OPCODE(LT);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t addr = x2_val + b2_val + d2;
   int32_t value = ReadW(addr, instr);
   set_low_register(r1, value);
   SetS390ConditionCode<int32_t>(value, 0);
   return length;
@@ skipping 76 matching lines @@
   USE(instr);
   return 0;
 }
 
 EVALUATE(DSGF) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
+EVALUATE(LRVG) {
+  DCHECK_OPCODE(LRVG);
+  DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
+  int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
+  int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
+  intptr_t mem_addr = b2_val + x2_val + d2;
+  int64_t mem_val = ReadW64(mem_addr, instr);
+  set_register(r1, ByteReverse(mem_val));
+  return length;
+}
+
 EVALUATE(LRV) {
   DCHECK_OPCODE(LRV);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   int32_t mem_val = ReadW(mem_addr, instr);
   set_low_register(r1, ByteReverse(mem_val));
   return length;
 }
@@ skipping 47 matching lines @@
   USE(instr);
   return 0;
 }
 
 EVALUATE(CVDG) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
-EVALUATE(STRVG) {
-  UNIMPLEMENTED();
-  USE(instr);
-  return 0;
-}
-
 EVALUATE(CGF) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
 }
 
 EVALUATE(CLGF) {
   UNIMPLEMENTED();
   USE(instr);
   return 0;
@@ skipping 21 matching lines @@
   DCHECK_OPCODE(STRV);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   WriteW(mem_addr, ByteReverse(r1_val), instr);
   return length;
 }
 
+EVALUATE(STRVG) {
+  DCHECK_OPCODE(STRVG);
+  DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
+  int64_t r1_val = get_register(r1);
+  int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
+  int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
+  intptr_t mem_addr = b2_val + x2_val + d2;
+  WriteDW(mem_addr, ByteReverse(r1_val));
+  return length;
+}
+
 EVALUATE(STRVH) {
   DCHECK_OPCODE(STRVH);
   DECODE_RXY_A_INSTRUCTION(r1, x2, b2, d2);
   int32_t r1_val = get_low_register<int32_t>(r1);
   int64_t x2_val = (x2 == 0) ? 0 : get_register(x2);
   int64_t b2_val = (b2 == 0) ? 0 : get_register(b2);
   intptr_t mem_addr = b2_val + x2_val + d2;
   int16_t result = static_cast<int16_t>(r1_val >> 16);
   WriteH(mem_addr, ByteReverse(result), instr);
   return length;
@@ skipping 1553 matching lines @@
   return 0;
 }
 
 #undef EVALUATE
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_S390