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

src/compiler/wasm-compiler.cc

Index: src/compiler/wasm-compiler.cc
diff --git a/src/compiler/wasm-compiler.cc b/src/compiler/wasm-compiler.cc
index 1d547113d270d6536bf719d10750dd6e8467b4f5..ad52e15385885d7d31f75fbd5712289a73fdc5af 100644
--- a/src/compiler/wasm-compiler.cc
+++ b/src/compiler/wasm-compiler.cc
@@ -2762,6 +2762,35 @@ Node* WasmGraphBuilder::LoadMem(wasm::LocalType type, MachineType memtype,
     load = BuildUnalignedLoad(type, memtype, index, offset, alignment);
   }
 
+#if defined(V8_TARGET_BIG_ENDIAN)
+  int numberOfBytes = 1 << ElementSizeLog2Of(memtype.representation());
+
+  switch (numberOfBytes) {

[ivica.bogosavljevic, 2016/07/06 11:28:48]

You are missing here proper handling of floating-point values. Word32ReverseByte
and Word64ReverseByte don't accept float and double, you need to fix this

+    case 1:
+      break;
+    case 2:
+      load = graph()->NewNode(jsgraph()->machine()->Word16ReverseBytes().op(),
+                              load);
+      if (memtype.IsSigned())
+        load =
+            graph()->NewNode(jsgraph()->machine()->Word32Sar(),
+                             graph()->NewNode(jsgraph()->machine()->Word32Shl(),
+                                              load, Int32Constant(16)),
+                             Int32Constant(16));
+      break;
+    case 4:
+      load = graph()->NewNode(jsgraph()->machine()->Word32ReverseBytes().op(),
+                              load);
+      break;
+    case 8:
+      load = graph()->NewNode(jsgraph()->machine()->Word64ReverseBytes().op(),
+                              load);

[ivica.bogosavljevic, 2016/06/29 14:21:59]

32 bit architectures don't have Word64ReverseByte instructions. I think you will
need to implement Word64ReverseBytes to Word32ReverseBytes in int64-lowering in
order to have everything working on 32 bit architectures

+      break;
+    default:
+      UNREACHABLE();
+  }
+#endif
+
   if (type == wasm::kAstI64 &&
       ElementSizeLog2Of(memtype.representation()) < 3) {
     // TODO(titzer): TF zeroes the upper bits of 64-bit loads for subword sizes.
@@ -2878,6 +2907,34 @@ Node* WasmGraphBuilder::StoreMem(MachineType memtype, Node* index,
   // WASM semantics throw on OOB. Introduce explicit bounds check.
   BoundsCheckMem(memtype, index, offset, position);
   StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
+
+#if defined(V8_TARGET_BIG_ENDIAN)
+  int numberOfBytes = 1 << ElementSizeLog2Of(memtype.representation());
+
+  switch (numberOfBytes) {
+    case 1:
+      break;
+    case 2:
+      val = graph()->NewNode(
+          memtype.IsSigned() ? jsgraph()->machine()->Word32Sar()
+                             : jsgraph()->machine()->Word32Shr(),
+          graph()->NewNode(jsgraph()->machine()->Word32ReverseBytes().op(),
+                           val),
+          jsgraph()->Int32Constant(32 - numberOfBytes * 8));
+      break;
+    case 4:
+      val = graph()->NewNode(jsgraph()->machine()->Word32ReverseBytes().op(),
+                             val);
+      break;
+    case 8:
+      val = graph()->NewNode(jsgraph()->machine()->Word64ReverseBytes().op(),
+                             val);
+      break;
+    default:
+      UNREACHABLE();
+  }
+#endif
+
   bool aligned = static_cast<int>(alignment) >=
                  ElementSizeLog2Of(memtype.representation());