[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 1035 matching lines @@
       return node;
       break;
     default:
       UNREACHABLE();
       break;
   }
 
   int i;
   uint32_t shiftCount;
 
-  for (i = 0, shiftCount = valueSizeInBits - 8; i < valueSizeInBits / 2;
-       i += 8, shiftCount -= 16) {
-    Node* shiftLower;
-    Node* shiftHigher;
-    Node* lowerByte;
-    Node* higherByte;
+  if (jsgraph()->machine()->ReverseBytesSupported(
+          valueSizeInBytes < 4 ? 4 : valueSizeInBytes)) {
+    switch (valueSizeInBytes) {
+      case 1:
+        break;
+      case 2:
+        result =
+            graph()->NewNode(m->Word32ReverseBytes().op(),

[ahaas, 2016/07/28 14:12:59]

Why do you sometimes use jsgraph()->machine()->..., and sometimes m->...? I
think you should decide for one and stick with it.

[john.yan, 2016/07/28 18:03:50]

Acknowledged.

+                             graph()->NewNode(shiftLeftOpcode, value,
+                                              jsgraph()->Int32Constant(16)));
+        break;
+      case 4:
+        result = graph()->NewNode(
+            jsgraph()->machine()->Word32ReverseBytes().op(), value);
+        break;
+      case 8:
+        result = graph()->NewNode(
+            jsgraph()->machine()->Word64ReverseBytes().op(), value);
+        break;
+      default:
+        UNREACHABLE();
+    }
+  } else {
+    for (i = 0, shiftCount = valueSizeInBits - 8; i < valueSizeInBits / 2;
+         i += 8, shiftCount -= 16) {
+      Node* shiftLower;
+      Node* shiftHigher;
+      Node* lowerByte;
+      Node* higherByte;
 
-    DCHECK(shiftCount > 0);
-    DCHECK((shiftCount + 8) % 16 == 0);
+      DCHECK(shiftCount > 0);
+      DCHECK((shiftCount + 8) % 16 == 0);
 
-    if (valueSizeInBits > 32) {
-      shiftLower = graph()->NewNode(shiftLeftOpcode, value,
-                                    jsgraph()->Int64Constant(shiftCount));
-      shiftHigher = graph()->NewNode(shiftRightOpcode, value,
-                                     jsgraph()->Int64Constant(shiftCount));
-      lowerByte = graph()->NewNode(
-          andOpcode, shiftLower,
-          jsgraph()->Int64Constant(static_cast<uint64_t>(0xFF)
-                                   << (valueSizeInBits - 8 - i)));
-      higherByte = graph()->NewNode(
-          andOpcode, shiftHigher,
-          jsgraph()->Int64Constant(static_cast<uint64_t>(0xFF) << i));
-    } else {
-      shiftLower = graph()->NewNode(shiftLeftOpcode, value,
-                                    jsgraph()->Int32Constant(shiftCount));
-      shiftHigher = graph()->NewNode(shiftRightOpcode, value,
-                                     jsgraph()->Int32Constant(shiftCount));
-      lowerByte = graph()->NewNode(
-          andOpcode, shiftLower,
-          jsgraph()->Int32Constant(static_cast<uint32_t>(0xFF)
-                                   << (valueSizeInBits - 8 - i)));
-      higherByte = graph()->NewNode(
-          andOpcode, shiftHigher,
-          jsgraph()->Int32Constant(static_cast<uint32_t>(0xFF) << i));
+      if (valueSizeInBits > 32) {
+        shiftLower = graph()->NewNode(shiftLeftOpcode, value,
+                                      jsgraph()->Int64Constant(shiftCount));
+        shiftHigher = graph()->NewNode(shiftRightOpcode, value,
+                                       jsgraph()->Int64Constant(shiftCount));
+        lowerByte = graph()->NewNode(
+            andOpcode, shiftLower,
+            jsgraph()->Int64Constant(static_cast<uint64_t>(0xFF)
+                                     << (valueSizeInBits - 8 - i)));
+        higherByte = graph()->NewNode(
+            andOpcode, shiftHigher,
+            jsgraph()->Int64Constant(static_cast<uint64_t>(0xFF) << i));
+      } else {
+        shiftLower = graph()->NewNode(shiftLeftOpcode, value,
+                                      jsgraph()->Int32Constant(shiftCount));
+        shiftHigher = graph()->NewNode(shiftRightOpcode, value,
+                                       jsgraph()->Int32Constant(shiftCount));
+        lowerByte = graph()->NewNode(
+            andOpcode, shiftLower,
+            jsgraph()->Int32Constant(static_cast<uint32_t>(0xFF)
+                                     << (valueSizeInBits - 8 - i)));
+        higherByte = graph()->NewNode(
+            andOpcode, shiftHigher,
+            jsgraph()->Int32Constant(static_cast<uint32_t>(0xFF) << i));
+      }
+
+      result = graph()->NewNode(orOpcode, result, lowerByte);
+      result = graph()->NewNode(orOpcode, result, higherByte);
     }
-
-    result = graph()->NewNode(orOpcode, result, lowerByte);
-    result = graph()->NewNode(orOpcode, result, higherByte);
   }
 
   if (isFloat) {
     switch (memtype.representation()) {
       case MachineRepresentation::kFloat64:
         result = graph()->NewNode(m->BitcastInt64ToFloat64(), result);
         break;
       case MachineRepresentation::kFloat32:
         result = graph()->NewNode(m->BitcastInt32ToFloat32(), result);
         break;
       default:
         UNREACHABLE();
         break;
     }
   }
 
   // We need to sign extend the value
   if (memtype.IsSigned()) {
     DCHECK(!isFloat);
     if (valueSizeInBits < 32) {
       Node* shiftBitCount;
       // Perform sign extension using following trick
       // result = (x << machine_width - type_width) >> (machine_width -
       // type_width)
       if (wasmtype == wasm::kAstI64) {
         shiftBitCount = jsgraph()->Int32Constant(64 - valueSizeInBits);
         result = graph()->NewNode(
             m->Word64Sar(),
-            graph()->NewNode(m->Word64Shl(), result, shiftBitCount),
+            graph()->NewNode(
+                m->Word64Shl(),
+                graph()->NewNode(jsgraph()->machine()->ChangeInt32ToInt64(),
+                                 result),
+                shiftBitCount),
             shiftBitCount);
       } else if (wasmtype == wasm::kAstI32) {
         shiftBitCount = jsgraph()->Int32Constant(32 - valueSizeInBits);
         result = graph()->NewNode(
             m->Word32Sar(),
             graph()->NewNode(m->Word32Shl(), result, shiftBitCount),
             shiftBitCount);
       }
     }
   }
@@ skipping 1942 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)
-  // TODO(john.yan) Implement byte swap turbofan operator
-  // and use it if available for better performance
   load = BuildChangeEndianness(load, memtype, type);
 #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 {
@@ skipping 99 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);
+
   bool aligned = static_cast<int>(alignment) >=
                  ElementSizeLog2Of(memtype.representation());
 
 #if defined(V8_TARGET_BIG_ENDIAN)
-  // TODO(john.yan) Implement byte swap turbofan operator
-  // and use it if available for better performance
   val = BuildChangeEndianness(val, memtype);
 #endif
 
   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 439 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8