[wasm] I added comparison operators 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"
 
@@ skipping 68 matching lines @@
   int64_t value(int i) { return value_[i]; }
 
   int32_t low_word_value(int i) {
     return static_cast<int32_t>(value_[i] & 0xffffffff);
   }
 
   int32_t high_word_value(int i) {
     return static_cast<int32_t>(value_[i] >> 32);
   }
 
+  void TestComparison(
+      const Operator* op,
+      Matcher<Node*> (*high_word_matcher)(const Matcher<Node*>& lhs_matcher,
+                                          const Matcher<Node*>& rhs_matcher),
+      Matcher<Node*> (*low_word_matcher)(const Matcher<Node*>& lhs_matcher,
+                                         const Matcher<Node*>& rhs_matcher)) {
+    LowerGraph(
+        graph()->NewNode(op, Int64Constant(value(0)), Int64Constant(value(1))),
+        MachineRepresentation::kWord32);
+    EXPECT_THAT(
+        graph()->end()->InputAt(1),
+        IsReturn(IsWord32Or(
+                     high_word_matcher(IsInt32Constant(high_word_value(0)),
+                                       IsInt32Constant(high_word_value(1))),
+                     IsWord32And(
+                         IsWord32Equal(IsInt32Constant(high_word_value(0)),
+                                       IsInt32Constant(high_word_value(1))),
+                         low_word_matcher(IsInt32Constant(low_word_value(0)),
+                                          IsInt32Constant(low_word_value(1))))),
+                 start(), start()));
+  }
+
  private:
   MachineOperatorBuilder machine_;
   int64_t value_[3];
 };
 
 TEST_F(Int64LoweringTest, Int64Constant) {
   if (4 != kPointerSize) return;
 
   LowerGraph(Int64Constant(value(0)), MachineRepresentation::kWord64);
   EXPECT_THAT(graph()->end()->InputAt(1),
@@ skipping 250 matching lines @@
                    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:
+TEST_F(Int64LoweringTest, Int64LtS) {
+  if (4 != kPointerSize) return;
+  TestComparison(machine()->Int64LessThan(), IsInt32LessThan, IsUint32LessThan);
+}
 // kExprI64LeS:
+TEST_F(Int64LoweringTest, Int64LeS) {
+  if (4 != kPointerSize) return;
+  TestComparison(machine()->Int64LessThanOrEqual(), IsInt32LessThan,
+                 IsUint32LessThanOrEqual);
+}
 // kExprI64LtU:
+TEST_F(Int64LoweringTest, Int64LtU) {
+  if (4 != kPointerSize) return;
+  TestComparison(machine()->Uint64LessThan(), IsUint32LessThan,
+                 IsUint32LessThan);
+}
 // kExprI64LeU:
-// kExprI64GtS:
-// kExprI64GeS:
-// kExprI64GtU:
-// kExprI64GeU:
+TEST_F(Int64LoweringTest, Int64LeU) {
+  if (4 != kPointerSize) return;
+  TestComparison(machine()->Uint64LessThanOrEqual(), IsUint32LessThan,
+                 IsUint32LessThanOrEqual);
+}
 
 // kExprI32ConvertI64:
 // kExprI64SConvertI32:
 // kExprI64UConvertI32:
 
 // kExprF64ReinterpretI64:
 // kExprI64ReinterpretF64:
 
 // kExprI64Clz:
 // kExprI64Ctz:
 // kExprI64Popcnt:
 
 // kExprF32SConvertI64:
 // kExprF32UConvertI64:
 // kExprF64SConvertI64:
 // kExprF64UConvertI64:
 // kExprI64SConvertF32:
 // kExprI64SConvertF64:
 // kExprI64UConvertF32:
 // kExprI64UConvertF64:
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8