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

src/compiler/simd-scalar-lowering.cc

 // Copyright 2016 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/simd-scalar-lowering.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
@@ skipping 258 matching lines @@
       type == SimdType::kSimd1x4) {
     num_lanes = kNumLanes32;
   } else if (type == SimdType::kInt16x8 || type == SimdType::kSimd1x8) {
     num_lanes = kNumLanes16;
   } else {
     UNREACHABLE();
   }
   return num_lanes;
 }
 
+constexpr int SimdScalarLowering::kLaneOffsets[];
+
 void SimdScalarLowering::GetIndexNodes(Node* index, Node** new_indices,
                                        SimdType type) {
-  new_indices[0] = index;
   int num_lanes = NumLanes(type);
   int lane_width = kSimd128Size / num_lanes;
+  int laneIndex = kLaneOffsets[0] / lane_width;
+  new_indices[laneIndex] = index;
   for (int i = 1; i < num_lanes; ++i) {
-    new_indices[i] = graph()->NewNode(machine()->Int32Add(), index,
-                                      graph()->NewNode(common()->Int32Constant(
-                                          static_cast<int>(i) * lane_width)));
+    laneIndex = kLaneOffsets[i * lane_width] / lane_width;
+    new_indices[laneIndex] = graph()->NewNode(
+        machine()->Int32Add(), index,
+        graph()->NewNode(
+            common()->Int32Constant(static_cast<int>(i) * lane_width)));
   }
 }
 
 void SimdScalarLowering::LowerLoadOp(MachineRepresentation rep, Node* node,
                                      const Operator* load_op, SimdType type) {
   if (rep == MachineRepresentation::kSimd128) {
     Node* base = node->InputAt(0);
     Node* index = node->InputAt(1);
     int num_lanes = NumLanes(type);
     Node** indices = zone()->NewArray<Node*>(num_lanes);
     GetIndexNodes(index, indices, type);
     Node** rep_nodes = zone()->NewArray<Node*>(num_lanes);
     rep_nodes[0] = node;
+    rep_nodes[0]->ReplaceInput(1, indices[0]);
     NodeProperties::ChangeOp(rep_nodes[0], load_op);
     if (node->InputCount() > 2) {
       DCHECK(node->InputCount() > 3);
       Node* effect_input = node->InputAt(2);
       Node* control_input = node->InputAt(3);
       for (int i = num_lanes - 1; i > 0; --i) {
         rep_nodes[i] = graph()->NewNode(load_op, base, indices[i], effect_input,
                                         control_input);
         effect_input = rep_nodes[i];
       }
@@ skipping 18 matching lines @@
     int num_lanes = NumLanes(rep_type);
     Node** indices = zone()->NewArray<Node*>(num_lanes);
     GetIndexNodes(index, indices, rep_type);
     DCHECK(node->InputCount() > 2);
     Node* value = node->InputAt(2);
     DCHECK(HasReplacement(1, value));
     Node** rep_nodes = zone()->NewArray<Node*>(num_lanes);
     rep_nodes[0] = node;
     Node** rep_inputs = GetReplacementsWithType(value, rep_type);
     rep_nodes[0]->ReplaceInput(2, rep_inputs[0]);
+    rep_nodes[0]->ReplaceInput(1, indices[0]);
     NodeProperties::ChangeOp(node, store_op);
     if (node->InputCount() > 3) {
       DCHECK(node->InputCount() > 4);
       Node* effect_input = node->InputAt(3);
       Node* control_input = node->InputAt(4);
       for (int i = num_lanes - 1; i > 0; --i) {
         rep_nodes[i] =
             graph()->NewNode(store_op, base, indices[i], rep_inputs[i],
                              effect_input, control_input);
         effect_input = rep_nodes[i];
       }
       rep_nodes[0]->ReplaceInput(3, rep_nodes[1]);
-
     } else {
       for (int i = 1; i < num_lanes; ++i) {
         rep_nodes[i] =
             graph()->NewNode(store_op, base, indices[i], rep_inputs[i]);
       }
     }
-
     ReplaceNode(node, rep_nodes, num_lanes);
   } else {
     DefaultLowering(node);
   }
 }
 
 void SimdScalarLowering::LowerBinaryOp(Node* node, SimdType input_rep_type,
                                        const Operator* op, bool invert_inputs) {
   DCHECK(node->InputCount() == 2);
   Node** rep_left = GetReplacementsWithType(node->InputAt(0), input_rep_type);
@@ skipping 779 matching lines @@
           UNREACHABLE();
       }
 #undef PHI_CASE
     }
     ReplaceNode(phi, rep_nodes, num_lanes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8