[wasm] Implement 128-bit endian swap for simd type

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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 1048 matching lines @@
                               jsgraph()->Int64Constant(kMask64));
     }
   }
   return node;
 }
 
 static bool ReverseBytesSupported(MachineOperatorBuilder* m,
                                   size_t size_in_bytes) {
   switch (size_in_bytes) {
     case 4:
+    case 16:
       return m->Word32ReverseBytes().IsSupported();
     case 8:
       return m->Word64ReverseBytes().IsSupported();
     default:
       break;
   }
   return false;
 }
 
 Node* WasmGraphBuilder::BuildChangeEndianness(Node* node, MachineType memtype,
@@ skipping 16 matching lines @@
       value = graph()->NewNode(m->BitcastFloat32ToInt32(), node);
       isFloat = true;
     case MachineRepresentation::kWord32:
     case MachineRepresentation::kWord16:
       result = jsgraph()->Int32Constant(0);
       break;
     case MachineRepresentation::kWord8:
       // No need to change endianness for byte size, return original node
       return node;
       break;
+    case MachineRepresentation::kSimd128:
+      DCHECK(ReverseBytesSupported(m, valueSizeInBytes));
+      break;
     default:
       UNREACHABLE();
       break;
   }
 
   int i;
   uint32_t shiftCount;
 
   if (ReverseBytesSupported(m, valueSizeInBytes < 4 ? 4 : valueSizeInBytes)) {
     switch (valueSizeInBytes) {
       case 2:
         result =
             graph()->NewNode(m->Word32ReverseBytes().op(),
                              graph()->NewNode(m->Word32Shl(), 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;
+      case 16: {
+        Node* byte_reversed_lanes[4];
+        result = value;
+        for (int lane = 0; lane < 4; lane++)
+          byte_reversed_lanes[lane] = graph()->NewNode(
+              m->Word32ReverseBytes().op(),
+              graph()->NewNode(jsgraph()->machine()->I32x4ExtractLane(lane),
+                               value));
+        for (int lane = 0; lane < 4; lane++)
+          result =
+              graph()->NewNode(jsgraph()->machine()->I32x4ReplaceLane(lane),
+                               result, byte_reversed_lanes[3 - lane]);
+
+        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;
@@ skipping 3005 matching lines @@
     wasm::ModuleBytesEnv* module_env, const wasm::WasmFunction* function) {
   WasmCompilationUnit unit(isolate, module_env, function);
   unit.InitializeHandles();
   unit.ExecuteCompilation();
   return unit.FinishCompilation(thrower);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8