[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 988 matching lines @@
       int64_t masked = (match.Value() & kMask64);
       if (match.Value() != masked) node = jsgraph()->Int64Constant(masked);
     } else {
       node = graph()->NewNode(jsgraph()->machine()->Word64And(), node,
                               jsgraph()->Int64Constant(kMask64));
     }
   }
   return node;
 }
 
+static bool ReverseBytesSupported(MachineOperatorBuilder* m,
+                                  size_t size_in_bytes) {
+  switch (size_in_bytes) {
+    case 4:
+      return m->Word32ReverseBytes().IsSupported();
+    case 8:
+      return m->Word64ReverseBytes().IsSupported();
+    default:
+      break;
+  }
+  return false;
+}
+
 Node* WasmGraphBuilder::BuildChangeEndianness(Node* node, MachineType memtype,
                                               wasm::LocalType wasmtype) {
   Node* result;
   Node* value = node;
   const Operator* shiftLeftOpcode;
   const Operator* shiftRightOpcode;
   const Operator* andOpcode;
   const Operator* orOpcode;
   MachineOperatorBuilder* m = jsgraph()->machine();
   int valueSizeInBytes = 1 << ElementSizeLog2Of(memtype.representation());
   int valueSizeInBits = 8 * valueSizeInBytes;
   bool isFloat = false;
 
   switch (memtype.representation()) {

[ahaas, 2016/07/29 04:15:18]

it seems to me that pre-calculating shiftLeftOpcode, shiftRightOpcode,
andOpcode, and orOpcode is unnecessary, because in the code below it is always
obvious which one should be used. For me the use of shiftLeftOpcode was
distracting, and I would prefer to read m->Word64Shl() instead of
shiftLeftOpcode because I am used to that.

nit: I think in V8 local variables do not use camel case but lower case words
with underscores. 

[john.yan, 2016/07/29 17:12:03]

xxxOpcode is now removed.

     case MachineRepresentation::kFloat64:
       value = graph()->NewNode(m->BitcastFloat64ToInt64(), node);
       isFloat = true;
     case MachineRepresentation::kWord64:
       shiftLeftOpcode = m->Word64Shl();
       shiftRightOpcode = m->Word64Shr();
       andOpcode = m->Word64And();
       orOpcode = m->Word64Or();
       result = jsgraph()->Int64Constant(0);
       break;
@@ skipping 13 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 (ReverseBytesSupported(m, valueSizeInBytes < 4 ? 4 : valueSizeInBytes)) {
+    switch (valueSizeInBytes) {
+      case 1:

[ahaas, 2016/07/29 04:15:18]

nit: you could remove this case, it should be unreachable because you return
already above when valueSizeInBytes == 1.

[john.yan, 2016/07/29 17:12:03]

Done.

+        break;
+      case 2:
+        result =
+            graph()->NewNode(m->Word32ReverseBytes().op(),
+                             graph()->NewNode(shiftLeftOpcode, value,
+                                              jsgraph()->Int32Constant(16)));
+        break;
+      case 4:
+        result = graph()->NewNode(m->Word32ReverseBytes().op(), value);
+        break;
+      case 8:
+        result = graph()->NewNode(m->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(m->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