[wasm] Mark all 64-bit instructions as supported on 32-bit platforms.

test/unittests/compiler/int64-lowering-unittest.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/int64-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
 
@@ skipping 283 matching lines @@
                       IsInt32Constant(low_word_value(2)),
                       IsInt32Constant(high_word_value(2)), start(), start()),
                start(), start()));
 
   CompareCallDescriptors(
       OpParameter<const CallDescriptor*>(
           graph()->end()->InputAt(1)->InputAt(0)),
       wasm::ModuleEnv::GetI32WasmCallDescriptor(zone(), desc));
 }
 
-// todo(ahaas): I added a list of missing instructions here to make merging
-// easier when I do them one by one.
-// kExprI64Add:
 TEST_F(Int64LoweringTest, Int64Add) {
   LowerGraph(graph()->NewNode(machine()->Int64Add(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> add;
   Matcher<Node*> add_matcher = IsInt32PairAdd(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)), IsInt32Constant(high_word_value(1)));
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsProjection(0, AllOf(CaptureEq(&add), add_matcher)),
                         IsProjection(1, AllOf(CaptureEq(&add), add_matcher)),
                         start(), start()));
 }
-// kExprI64Sub:
+
 TEST_F(Int64LoweringTest, Int64Sub) {
   LowerGraph(graph()->NewNode(machine()->Int64Sub(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> sub;
   Matcher<Node*> sub_matcher = IsInt32PairSub(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)), IsInt32Constant(high_word_value(1)));
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsProjection(0, AllOf(CaptureEq(&sub), sub_matcher)),
                         IsProjection(1, AllOf(CaptureEq(&sub), sub_matcher)),
                         start(), start()));
 }
 
-// kExprI64Mul:
 TEST_F(Int64LoweringTest, Int64Mul) {
   LowerGraph(graph()->NewNode(machine()->Int64Mul(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> mul_capture;
   Matcher<Node*> mul_matcher = IsInt32PairMul(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)), IsInt32Constant(high_word_value(1)));
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(IsProjection(0, AllOf(CaptureEq(&mul_capture), mul_matcher)),
                 IsProjection(1, AllOf(CaptureEq(&mul_capture), mul_matcher)),
                 start(), start()));
 }
 
-// kExprI64DivS:
-// kExprI64DivU:
-// kExprI64RemS:
-// kExprI64RemU:
-// kExprI64Ior:
 TEST_F(Int64LoweringTest, Int64Ior) {
   LowerGraph(graph()->NewNode(machine()->Word64Or(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsWord32Or(IsInt32Constant(low_word_value(0)),
                                    IsInt32Constant(low_word_value(1))),
                         IsWord32Or(IsInt32Constant(high_word_value(0)),
                                    IsInt32Constant(high_word_value(1))),
                         start(), start()));
 }
 
-// kExprI64Xor:
 TEST_F(Int64LoweringTest, Int64Xor) {
   LowerGraph(graph()->NewNode(machine()->Word64Xor(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsWord32Xor(IsInt32Constant(low_word_value(0)),
                                     IsInt32Constant(low_word_value(1))),
                         IsWord32Xor(IsInt32Constant(high_word_value(0)),
                                     IsInt32Constant(high_word_value(1))),
                         start(), start()));
 }
-// kExprI64Shl:
+
 TEST_F(Int64LoweringTest, Int64Shl) {
   LowerGraph(graph()->NewNode(machine()->Word64Shl(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> shl;
   Matcher<Node*> shl_matcher = IsWord32PairShl(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)));
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsProjection(0, AllOf(CaptureEq(&shl), shl_matcher)),
                         IsProjection(1, AllOf(CaptureEq(&shl), shl_matcher)),
                         start(), start()));
 }
-// kExprI64ShrU:
+
 TEST_F(Int64LoweringTest, Int64ShrU) {
   LowerGraph(graph()->NewNode(machine()->Word64Shr(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> shr;
   Matcher<Node*> shr_matcher = IsWord32PairShr(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)));
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsProjection(0, AllOf(CaptureEq(&shr), shr_matcher)),
                         IsProjection(1, AllOf(CaptureEq(&shr), shr_matcher)),
                         start(), start()));
 }
-// kExprI64ShrS:
+
 TEST_F(Int64LoweringTest, Int64ShrS) {
   LowerGraph(graph()->NewNode(machine()->Word64Sar(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> sar;
   Matcher<Node*> sar_matcher = IsWord32PairSar(
       IsInt32Constant(low_word_value(0)), IsInt32Constant(high_word_value(0)),
       IsInt32Constant(low_word_value(1)));
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsProjection(0, AllOf(CaptureEq(&sar), sar_matcher)),
                         IsProjection(1, AllOf(CaptureEq(&sar), sar_matcher)),
                         start(), start()));
 }
-// kExprI64Eq:
+
 TEST_F(Int64LoweringTest, Int64Eq) {
   LowerGraph(graph()->NewNode(machine()->Word64Equal(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord32);
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn(IsWord32Equal(
                    IsWord32Or(IsWord32Xor(IsInt32Constant(low_word_value(0)),
                                           IsInt32Constant(low_word_value(1))),
                               IsWord32Xor(IsInt32Constant(high_word_value(0)),
                                           IsInt32Constant(high_word_value(1)))),
                    IsInt32Constant(0)),
                start(), start()));
 }
 
-// kExprI64LtS:
 TEST_F(Int64LoweringTest, Int64LtS) {
   TestComparison(machine()->Int64LessThan(), IsInt32LessThan, IsUint32LessThan);
 }
-// kExprI64LeS:
+
 TEST_F(Int64LoweringTest, Int64LeS) {
   TestComparison(machine()->Int64LessThanOrEqual(), IsInt32LessThan,
                  IsUint32LessThanOrEqual);
 }
-// kExprI64LtU:
+
 TEST_F(Int64LoweringTest, Int64LtU) {
   TestComparison(machine()->Uint64LessThan(), IsUint32LessThan,
                  IsUint32LessThan);
 }
-// kExprI64LeU:
+
 TEST_F(Int64LoweringTest, Int64LeU) {
   TestComparison(machine()->Uint64LessThanOrEqual(), IsUint32LessThan,
                  IsUint32LessThanOrEqual);
 }
 
-// kExprI32ConvertI64:
 TEST_F(Int64LoweringTest, I32ConvertI64) {
   LowerGraph(graph()->NewNode(machine()->TruncateInt64ToInt32(),
                               Int64Constant(value(0))),
              MachineRepresentation::kWord32);
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn(IsInt32Constant(low_word_value(0)), start(), start()));
 }
-// kExprI64SConvertI32:
+
 TEST_F(Int64LoweringTest, I64SConvertI32) {
   LowerGraph(graph()->NewNode(machine()->ChangeInt32ToInt64(),
                               Int32Constant(low_word_value(0))),
              MachineRepresentation::kWord64);
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsInt32Constant(low_word_value(0)),
                         IsWord32Sar(IsInt32Constant(low_word_value(0)),
                                     IsInt32Constant(31)),
                         start(), start()));
 }
 
 TEST_F(Int64LoweringTest, I64SConvertI32_2) {
   LowerGraph(
       graph()->NewNode(machine()->ChangeInt32ToInt64(),
                        graph()->NewNode(machine()->TruncateInt64ToInt32(),
                                         Int64Constant(value(0)))),
       MachineRepresentation::kWord64);
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsInt32Constant(low_word_value(0)),
                         IsWord32Sar(IsInt32Constant(low_word_value(0)),
                                     IsInt32Constant(31)),
                         start(), start()));
 }
-// kExprI64UConvertI32:
+
 TEST_F(Int64LoweringTest, I64UConvertI32) {
   LowerGraph(graph()->NewNode(machine()->ChangeUint32ToUint64(),
                               Int32Constant(low_word_value(0))),
              MachineRepresentation::kWord64);
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsInt32Constant(low_word_value(0)), IsInt32Constant(0),
                         start(), start()));
 }
 
 TEST_F(Int64LoweringTest, I64UConvertI32_2) {
   LowerGraph(
       graph()->NewNode(machine()->ChangeUint32ToUint64(),
                        graph()->NewNode(machine()->TruncateInt64ToInt32(),
                                         Int64Constant(value(0)))),
       MachineRepresentation::kWord64);
 
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsInt32Constant(low_word_value(0)), IsInt32Constant(0),
                         start(), start()));
 }
-// kExprF64ReinterpretI64:
+
 TEST_F(Int64LoweringTest, F64ReinterpretI64) {
   LowerGraph(graph()->NewNode(machine()->BitcastInt64ToFloat64(),
                               Int64Constant(value(0))),
              MachineRepresentation::kFloat64);
 
   Capture<Node*> stack_slot_capture;
   Matcher<Node*> stack_slot_matcher =
       IsStackSlot(MachineRepresentation::kWord64);
 
   Capture<Node*> store_capture;
@@ skipping 10 matching lines @@
               start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn(IsLoad(MachineType::Float64(),
                       AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
                       IsInt32Constant(0),
                       AllOf(CaptureEq(&store_capture), store_matcher), start()),
                start(), start()));
 }
-// kExprI64ReinterpretF64:
+
 TEST_F(Int64LoweringTest, I64ReinterpretF64) {
   LowerGraph(graph()->NewNode(machine()->BitcastFloat64ToInt64(),
                               Float64Constant(bit_cast<double>(value(0)))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> stack_slot;
   Matcher<Node*> stack_slot_matcher =
       IsStackSlot(MachineRepresentation::kWord64);
 
   Capture<Node*> store;
   Matcher<Node*> store_matcher = IsStore(
       StoreRepresentation(MachineRepresentation::kFloat64,
                           WriteBarrierKind::kNoWriteBarrier),
       AllOf(CaptureEq(&stack_slot), stack_slot_matcher), IsInt32Constant(0),
       IsFloat64Constant(bit_cast<double>(value(0))), start(), start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(IsLoad(MachineType::Int32(),
                        AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
                        IsInt32Constant(0),
                        AllOf(CaptureEq(&store), store_matcher), start()),
                 IsLoad(MachineType::Int32(),
                        AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
                        IsInt32Constant(0x4),
                        AllOf(CaptureEq(&store), store_matcher), start()),
                 start(), start()));
 }
-// kExprI64Clz:
+
 TEST_F(Int64LoweringTest, I64Clz) {
   LowerGraph(graph()->NewNode(machine()->Word64Clz(), Int64Constant(value(0))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> branch_capture;
   Matcher<Node*> branch_matcher = IsBranch(
       IsWord32Equal(IsInt32Constant(high_word_value(0)), IsInt32Constant(0)),
       start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(
           IsPhi(MachineRepresentation::kWord32,
                 IsInt32Add(IsWord32Clz(IsInt32Constant(low_word_value(0))),
                            IsInt32Constant(32)),
                 IsWord32Clz(IsInt32Constant(high_word_value(0))),
                 IsMerge(
                     IsIfTrue(AllOf(CaptureEq(&branch_capture), branch_matcher)),
                     IsIfFalse(
                         AllOf(CaptureEq(&branch_capture), branch_matcher)))),
           IsInt32Constant(0), start(), start()));
 }
-// kExprI64Ctz:
+
 TEST_F(Int64LoweringTest, I64Ctz) {
   LowerGraph(graph()->NewNode(machine()->Word64CtzPlaceholder(),
                               Int64Constant(value(0))),
              MachineRepresentation::kWord64);
   Capture<Node*> branch_capture;
   Matcher<Node*> branch_matcher = IsBranch(
       IsWord32Equal(IsInt32Constant(low_word_value(0)), IsInt32Constant(0)),
       start());
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(
           IsPhi(MachineRepresentation::kWord32,
                 IsInt32Add(IsWord32Ctz(IsInt32Constant(high_word_value(0))),
                            IsInt32Constant(32)),
                 IsWord32Ctz(IsInt32Constant(low_word_value(0))),
                 IsMerge(
                     IsIfTrue(AllOf(CaptureEq(&branch_capture), branch_matcher)),
                     IsIfFalse(
                         AllOf(CaptureEq(&branch_capture), branch_matcher)))),
           IsInt32Constant(0), start(), start()));
 }
-// kExprI64Popcnt:
 
 TEST_F(Int64LoweringTest, Dfs) {
   Node* common = Int64Constant(value(0));
   LowerGraph(graph()->NewNode(machine()->Word64And(), common,
                               graph()->NewNode(machine()->Word64And(), common,
                                                Int64Constant(value(1)))),
              MachineRepresentation::kWord64);
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
@@ skipping 154 matching lines @@
           Float32Constant(2.5));
 }
 
 TEST_F(Int64LoweringTest, I64PhiWord32) {
   TestPhi(this, MachineRepresentation::kWord32, Float32Constant(1),
           Float32Constant(2));
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8