[wasm] I added comparison operators to the Int64Lowering.

src/compiler/int64-lowering.cc

 // Copyright 2014 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/graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
@@ skipping 295 matching lines @@
                                GetReplacementLow(right)),
               graph()->NewNode(machine()->Word32Xor(), GetReplacementHigh(left),
                                GetReplacementHigh(right))),
           graph()->NewNode(common()->Int32Constant(0)));
 
       ReplaceNode(node, replacement, nullptr);
       break;
     }
     // kExprI64Ne:
     // kExprI64LtS:
-    // kExprI64LeS:
-    // kExprI64LtU:
-    // kExprI64LeU:
-    // kExprI64GtS:
-    // kExprI64GeS:
-    // kExprI64GtU:
-    // kExprI64GeU:
+    case IrOpcode::kInt64LessThan: {
+      LowerComparison(node, machine()->Int32LessThan(),
+                      machine()->Uint32LessThan());
+      break;
+    }
+    case IrOpcode::kInt64LessThanOrEqual: {
+      LowerComparison(node, machine()->Int32LessThan(),
+                      machine()->Uint32LessThanOrEqual());
+      break;
+    }
+    case IrOpcode::kUint64LessThan: {
+      LowerComparison(node, machine()->Uint32LessThan(),
+                      machine()->Uint32LessThan());
+      break;
+    }
+    case IrOpcode::kUint64LessThanOrEqual: {
+      LowerComparison(node, machine()->Uint32LessThan(),
+                      machine()->Uint32LessThanOrEqual());
+      break;
+    }
 
     // kExprI64SConvertI32:
     // kExprI64UConvertI32:
 
     // kExprF64ReinterpretI64:
     // kExprI64ReinterpretF64:
 
     // kExprI64Clz:
     // kExprI64Ctz:
     // kExprI64Popcnt:
 
     // kExprF32SConvertI64:
     // kExprF32UConvertI64:
     // kExprF64SConvertI64:
     // kExprF64UConvertI64:
     // kExprI64SConvertF32:
     // kExprI64SConvertF64:
     // kExprI64UConvertF32:
     // kExprI64UConvertF64:
     default: { DefaultLowering(node); }
   }
 }
 
+void Int64Lowering::LowerComparison(Node* node, const Operator* high_word_op,
+                                    const Operator* low_word_op) {
+  DCHECK(node->InputCount() == 2);
+  Node* left = node->InputAt(0);
+  Node* right = node->InputAt(1);
+  Node* replacement = graph()->NewNode(
+      machine()->Word32Or(),
+      graph()->NewNode(high_word_op, GetReplacementHigh(left),
+                       GetReplacementHigh(right)),
+      graph()->NewNode(
+          machine()->Word32And(),
+          graph()->NewNode(machine()->Word32Equal(), GetReplacementHigh(left),
+                           GetReplacementHigh(right)),
+          graph()->NewNode(low_word_op, GetReplacementLow(left),
+                           GetReplacementLow(right))));
+
+  ReplaceNode(node, replacement, nullptr);
+}
+
 bool Int64Lowering::DefaultLowering(Node* node) {
   bool something_changed = false;
   for (int i = NodeProperties::PastValueIndex(node) - 1; i >= 0; i--) {
     Node* input = node->InputAt(i);
     if (HasReplacementLow(input)) {
       something_changed = true;
       node->ReplaceInput(i, GetReplacementLow(input));
     }
     if (HasReplacementHigh(input)) {
       something_changed = true;
@@ skipping 25 matching lines @@
 }
 
 Node* Int64Lowering::GetReplacementHigh(Node* node) {
   Node* result = replacements_[node->id()].high;
   DCHECK(result);
   return result;
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8