[WASM] Eliminate SIMD boolean vector types.

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 198 matching lines @@
     case IrOpcode::kCall: {
       replacements_[node->id()].type = SimdType::kInt32x4;
       break;
     }
       FOREACH_FLOAT32X4_OPCODE(CASE_STMT) {
         replacements_[node->id()].type = SimdType::kFloat32x4;
         break;
       }
       FOREACH_FLOAT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
       FOREACH_INT32X4_TO_SIMD1X4OPCODE(CASE_STMT) {
-        replacements_[node->id()].type = SimdType::kSimd1x4;
+        replacements_[node->id()].type = SimdType::kInt32x4;
         break;
       }
       FOREACH_INT16X8_OPCODE(CASE_STMT) {
         replacements_[node->id()].type = SimdType::kInt16x8;
         break;
       }
       FOREACH_INT16X8_TO_SIMD1X8OPCODE(CASE_STMT) {
-        replacements_[node->id()].type = SimdType::kSimd1x8;
+        replacements_[node->id()].type = SimdType::kInt16x8;
         break;
       }
       FOREACH_INT8X16_OPCODE(CASE_STMT) {
         replacements_[node->id()].type = SimdType::kInt8x16;
         break;
       }
       FOREACH_INT8X16_TO_SIMD1X16OPCODE(CASE_STMT) {
-        replacements_[node->id()].type = SimdType::kSimd1x16;
+        replacements_[node->id()].type = SimdType::kInt8x16;
         break;
       }
     default: {
       switch (output->opcode()) {
         FOREACH_FLOAT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
         case IrOpcode::kF32x4SConvertI32x4:
         case IrOpcode::kF32x4UConvertI32x4: {
           replacements_[node->id()].type = SimdType::kInt32x4;
           break;
         }
           FOREACH_INT32X4_TO_SIMD1X4OPCODE(CASE_STMT)
         case IrOpcode::kI32x4SConvertF32x4:
         case IrOpcode::kI32x4UConvertF32x4: {
           replacements_[node->id()].type = SimdType::kFloat32x4;
           break;
         }
-        case IrOpcode::kS32x4Select: {
-          replacements_[node->id()].type = SimdType::kSimd1x4;
+        case IrOpcode::kS128Select: {
+          replacements_[node->id()].type = SimdType::kInt32x4;
           break;
         }
           FOREACH_INT16X8_TO_SIMD1X8OPCODE(CASE_STMT) {
             replacements_[node->id()].type = SimdType::kInt16x8;
             break;
           }
           FOREACH_INT8X16_TO_SIMD1X16OPCODE(CASE_STMT) {
             replacements_[node->id()].type = SimdType::kInt8x16;
             break;
           }
-        case IrOpcode::kS16x8Select: {
-          replacements_[node->id()].type = SimdType::kSimd1x8;
-          break;
-        }
         default: {
           replacements_[node->id()].type = replacements_[output->id()].type;
         }
       }
     }
 #undef CASE_STMT
   }
 }
 
 static int GetParameterIndexAfterLowering(
@@ skipping 25 matching lines @@
   for (int i = 0; i < static_cast<int>(signature->return_count()); ++i) {
     if (signature->GetReturn(i) == MachineRepresentation::kSimd128) {
       result += 3;
     }
   }
   return result;
 }
 
 int SimdScalarLowering::NumLanes(SimdType type) {
   int num_lanes = 0;
-  if (type == SimdType::kFloat32x4 || type == SimdType::kInt32x4 ||
-      type == SimdType::kSimd1x4) {
+  if (type == SimdType::kFloat32x4 || type == SimdType::kInt32x4) {
     num_lanes = kNumLanes32;
-  } else if (type == SimdType::kInt16x8 || type == SimdType::kSimd1x8) {
+  } else if (type == SimdType::kInt16x8) {
     num_lanes = kNumLanes16;
-  } else if (type == SimdType::kInt8x16 || type == SimdType::kSimd1x16) {
+  } else if (type == SimdType::kInt8x16) {
     num_lanes = kNumLanes8;
   } else {
     UNREACHABLE();
   }
   return num_lanes;
 }
 
 constexpr int SimdScalarLowering::kLaneOffsets[];
 
 void SimdScalarLowering::GetIndexNodes(Node* index, Node** new_indices,
@@ skipping 768 matching lines @@
       break;
     }
     case IrOpcode::kI16x8Ne: {
       LowerNotEqual(node, SimdType::kInt16x8, machine()->Word32Equal());
       break;
     }
     case IrOpcode::kI8x16Ne: {
       LowerNotEqual(node, SimdType::kInt8x16, machine()->Word32Equal());
       break;
     }
-    case IrOpcode::kS32x4Select:
-    case IrOpcode::kS16x8Select:
-    case IrOpcode::kS8x16Select: {
+    case IrOpcode::kS128Select: {
       DCHECK(node->InputCount() == 3);
-      DCHECK(ReplacementType(node->InputAt(0)) == SimdType::kSimd1x4 ||
-             ReplacementType(node->InputAt(0)) == SimdType::kSimd1x8 ||
-             ReplacementType(node->InputAt(0)) == SimdType::kSimd1x16);
+      DCHECK(ReplacementType(node->InputAt(0)) == SimdType::kInt32x4 ||
+             ReplacementType(node->InputAt(0)) == SimdType::kInt16x8 ||
+             ReplacementType(node->InputAt(0)) == SimdType::kInt8x16);
       Node** boolean_input = GetReplacements(node->InputAt(0));
       Node** rep_left = GetReplacementsWithType(node->InputAt(1), rep_type);
       Node** rep_right = GetReplacementsWithType(node->InputAt(2), rep_type);
       Node** rep_node = zone()->NewArray<Node*>(num_lanes);
       for (int i = 0; i < num_lanes; ++i) {
         Diamond d(graph(), common(),
                   graph()->NewNode(machine()->Word32Equal(), boolean_input[i],
                                    jsgraph_->Int32Constant(0)));
 #define SELECT_CASE(sType, mType)                                          \
   case SimdType::k##sType:                                                 \
@@ skipping 153 matching lines @@
           UNREACHABLE();
       }
 #undef PHI_CASE
     }
     ReplaceNode(phi, rep_nodes, num_lanes);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8