[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 181 matching lines @@
     Signature<MachineRepresentation>* signature) {
   int result = static_cast<int>(signature->return_count());
   for (int i = 0; i < static_cast<int>(signature->return_count()); ++i) {
     if (signature->GetReturn(i) == MachineRepresentation::kSimd128) {
       result += 3;
     }
   }
   return result;
 }
 
+constexpr int SimdScalarLowering::kLaneOffsets[];
+
 void SimdScalarLowering::GetIndexNodes(Node* index, Node** new_indices) {
-  new_indices[0] = index;
+  int laneIndex = kLaneOffsets[0];
+  new_indices[laneIndex] = index;
   for (size_t i = 1; i < kMaxLanes; ++i) {
-    new_indices[i] = graph()->NewNode(machine()->Int32Add(), index,
-                                      graph()->NewNode(common()->Int32Constant(
-                                          static_cast<int>(i) * kLaneWidth)));
+    laneIndex = kLaneOffsets[i];
+    new_indices[laneIndex] = graph()->NewNode(
+        machine()->Int32Add(), index,
+        graph()->NewNode(
+            common()->Int32Constant(static_cast<int>(i) * kLaneWidth)));
   }
 }
 
 void SimdScalarLowering::LowerLoadOp(MachineRepresentation rep, Node* node,
                                      const Operator* load_op) {
   if (rep == MachineRepresentation::kSimd128) {
     Node* base = node->InputAt(0);
     Node* index = node->InputAt(1);
     Node* indices[kMaxLanes];
     GetIndexNodes(index, indices);
     Node* rep_nodes[kMaxLanes];
     rep_nodes[0] = node;
     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);
       rep_nodes[3] = graph()->NewNode(load_op, base, indices[3], effect_input,
                                       control_input);
       rep_nodes[2] = graph()->NewNode(load_op, base, indices[2], rep_nodes[3],
                                       control_input);
       rep_nodes[1] = graph()->NewNode(load_op, base, indices[1], rep_nodes[2],
                                       control_input);
       rep_nodes[0]->ReplaceInput(2, rep_nodes[1]);
+      rep_nodes[0]->ReplaceInput(1, indices[0]);

[aseemgarg, 2017/05/02 21:20:21]

This is not correct. The else case (without control and effect nodes) is not
covered. Also, this needs to be rebased. The code has changed somewhat over here
(Int16x8 was added). 

[john.yan, 2017/05/03 19:39:40]

Hello, do you mean the else case below? I don't understand how it will affect
anything from above. Could you please explain a bit more?

Thanks,
John

[aseemgarg, 2017/05/03 22:04:13]

yes the else case below. Since the indices have potentially moved around, the
index for rep_node[0] should be fixed even for the else case. 

     } else {
       for (size_t i = 1; i < kMaxLanes; ++i) {
         rep_nodes[i] = graph()->NewNode(load_op, base, indices[i]);
       }
     }
     ReplaceNode(node, rep_nodes);
   } else {
     DefaultLowering(node);
   }
 }
@@ skipping 18 matching lines @@
       DCHECK(node->InputCount() > 4);
       Node* effect_input = node->InputAt(3);
       Node* control_input = node->InputAt(4);
       rep_nodes[3] = graph()->NewNode(store_op, base, indices[3], rep_inputs[3],
                                       effect_input, control_input);
       rep_nodes[2] = graph()->NewNode(store_op, base, indices[2], rep_inputs[2],
                                       rep_nodes[3], control_input);
       rep_nodes[1] = graph()->NewNode(store_op, base, indices[1], rep_inputs[1],
                                       rep_nodes[2], control_input);
       rep_nodes[0]->ReplaceInput(3, rep_nodes[1]);
+      rep_nodes[0]->ReplaceInput(1, indices[0]);
 
     } else {
       for (size_t i = 1; i < kMaxLanes; ++i) {
         rep_nodes[i] =
             graph()->NewNode(store_op, base, indices[i], rep_inputs[i]);
       }
     }
 
     ReplaceNode(node, rep_nodes);
   } else {
@@ skipping 582 matching lines @@
       } else {
         UNREACHABLE();
       }
     }
     ReplaceNode(phi, rep_nodes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8