[wasm] I added I64Eq to the Int64Lowering.

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"
 
 #include "src/compiler/node-properties.h"
 
 #include "src/signature.h"
 
 #include "src/wasm/wasm-module.h"
 
 #include "test/unittests/compiler/graph-unittest.h"
 #include "test/unittests/compiler/node-test-utils.h"
+#include "testing/gmock-support.h"
+
+using testing::AllOf;
+using testing::Capture;
+using testing::CaptureEq;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class Int64LoweringTest : public GraphTest {
  public:
   Int64LoweringTest() : GraphTest(), machine_(zone()) {
     value_[0] = 0x1234567890abcdef;
     value_[1] = 0x1edcba098765432f;
@@ skipping 70 matching lines @@
   if (4 != kPointerSize) return;
 
   int32_t base = 0x1234;
   int32_t index = 0x5678;
 
   LowerGraph(graph()->NewNode(machine()->Load(MachineType::Int64()),
                               Int32Constant(base), Int32Constant(index),
                               start(), start()),
              MachineRepresentation::kWord64);
 
+  Capture<Node*> high_word_load;
   Matcher<Node*> high_word_load_matcher =
       IsLoad(MachineType::Int32(), IsInt32Constant(base),
              IsInt32Add(IsInt32Constant(index), IsInt32Constant(0x4)), start(),
              start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(IsLoad(MachineType::Int32(), IsInt32Constant(base),
-                       IsInt32Constant(index), high_word_load_matcher, start()),
-                high_word_load_matcher, start(), start()));
+                       IsInt32Constant(index), AllOf(CaptureEq(&high_word_load),
+                                                     high_word_load_matcher),
+                       start()),
+                AllOf(CaptureEq(&high_word_load), high_word_load_matcher),
+                start(), start()));
 }
 
 TEST_F(Int64LoweringTest, Int64Store) {
   if (4 != kPointerSize) return;
 
   // We have to build the TF graph explicitly here because Store does not return
   // a value.
 
   int32_t base = 1111;
   int32_t index = 2222;
@@ skipping 98 matching lines @@
   Signature<MachineRepresentation>::Builder sig_builder(zone(), 1, 0);
   sig_builder.AddReturn(MachineRepresentation::kWord64);
 
   compiler::CallDescriptor* desc =
       wasm::ModuleEnv::GetWasmCallDescriptor(zone(), sig_builder.Build());
 
   LowerGraph(graph()->NewNode(common()->Call(desc), Int32Constant(function),
                               start(), start()),
              MachineRepresentation::kWord64);
 
+  Capture<Node*> call;
   Matcher<Node*> call_matcher =
       IsCall(testing::_, IsInt32Constant(function), start(), start());
 
   EXPECT_THAT(graph()->end()->InputAt(1),
-              IsReturn2(IsProjection(0, call_matcher),
-                        IsProjection(1, call_matcher), start(), start()));
+              IsReturn2(IsProjection(0, AllOf(CaptureEq(&call), call_matcher)),
+                        IsProjection(1, AllOf(CaptureEq(&call), call_matcher)),
+                        start(), start()));
 
   CompareCallDescriptors(
       OpParameter<const CallDescriptor*>(
           graph()->end()->InputAt(1)->InputAt(0)->InputAt(0)),
       wasm::ModuleEnv::GetI32WasmCallDescriptor(zone(), desc));
 }
 
 TEST_F(Int64LoweringTest, CallI64Parameter) {
   if (4 != kPointerSize) return;
 
@@ skipping 66 matching lines @@
               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:
 // kExprI64ShrU:
 // kExprI64ShrS:
 // kExprI64Eq:
+TEST_F(Int64LoweringTest, Int64Eq) {
+  if (4 != kPointerSize) return;
+
+  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()));
+}
+
 // kExprI64Ne:
 // kExprI64LtS:
 // kExprI64LeS:
 // kExprI64LtU:
 // kExprI64LeU:
 // kExprI64GtS:
 // kExprI64GeS:
 // kExprI64GtU:
 // kExprI64GeU:
 
@@ skipping 13 matching lines @@
 // kExprF64SConvertI64:
 // kExprF64UConvertI64:
 // kExprI64SConvertF32:
 // kExprI64SConvertF64:
 // kExprI64UConvertF32:
 // kExprI64UConvertF64:
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8