[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 182 matching lines @@
   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;
 }
 
 void SimdScalarLowering::GetIndexNodes(Node* index, Node** new_indices) {
+#if defined(V8_TARGET_BIG_ENDIAN)

[Clemens Hammacher, 2017/04/28 09:45:47]

It looks like this code would get a lot cleaner if we introduce something like
this in the header:

#if defined(V8_TARGET_BIG_ENDIAN)                                               
   
  static constexpr int kLaneOffsets[] = {3, 2, 1, 0};                           

#else                                                                           
   
  static constexpr int kLaneOffsets[] = {0, 1, 2, 3};                           
   
#endif                                                                          
   

+  new_indices[3] = index;
+  for (size_t i = 0; i < kMaxLanes - 1; ++i) {
+    new_indices[i] = graph()->NewNode(
+        machine()->Int32Add(), index,
+        graph()->NewNode(common()->Int32Constant(
+            static_cast<int>(kMaxLanes - i - 1) * kLaneWidth)));
+  }
+#else
   new_indices[0] = 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)));
   }
+#endif
 }
 
 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]);
     } 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