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

src/compiler/wasm-compiler.cc

 // Copyright 2015 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 "src/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 2744 matching lines @@
 
   if (aligned ||
       jsgraph()->machine()->UnalignedLoadSupported(memtype, alignment)) {
     load = graph()->NewNode(jsgraph()->machine()->Load(memtype),
                             MemBuffer(offset), index, *effect_, *control_);
     *effect_ = load;
   } else {
     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.
     if (memtype.IsSigned()) {
       // sign extend
       load = graph()->NewNode(jsgraph()->machine()->ChangeInt32ToInt64(), load);
     } else {
       // zero extend
       load =
           graph()->NewNode(jsgraph()->machine()->ChangeUint32ToUint64(), load);
@@ skipping 96 matching lines @@
 }
 
 Node* WasmGraphBuilder::StoreMem(MachineType memtype, Node* index,
                                  uint32_t offset, uint32_t alignment, Node* val,
                                  wasm::WasmCodePosition position) {
   Node* store;
 
   // 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());
 
   if (aligned ||
       jsgraph()->machine()->UnalignedStoreSupported(memtype, alignment)) {
     StoreRepresentation rep(memtype.representation(), kNoWriteBarrier);
     store =
         graph()->NewNode(jsgraph()->machine()->Store(rep), MemBuffer(offset),
                          index, val, *effect_, *control_);
     *effect_ = store;
@@ skipping 407 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8