Lower simplified StringLessThan[OrEqual] to runtime call.

src/compiler/machine-operator.h

 // Copyright 2013 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.
 
 #ifndef V8_COMPILER_MACHINE_OPERATOR_H_
 #define V8_COMPILER_MACHINE_OPERATOR_H_
 
 #include "src/compiler/machine-type.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
@@ skipping 42 matching lines @@
   SIMPLE(name,                                                                 \
          Operator::kAssociative | Operator::kCommutative | Operator::kPure, 2, \
          1)
 #define BINOP_ACO(name)                                                        \
   SIMPLE(name,                                                                 \
          Operator::kAssociative | Operator::kCommutative | Operator::kPure, 2, \
          2)
 #define UNOP(name) SIMPLE(name, Operator::kPure, 1, 1)
 
 #define WORD_SIZE(x) return is64() ? Word64##x() : Word32##x()
+#define INT_SIZE(x) return is64() ? Int64##x() : Int32##x()
 
   Operator* Load(MachineType rep) {  // load [base + index]
     OP1(Load, MachineType, rep, Operator::kNoWrite, 2, 1);
   }
   // store [base + index], value
   Operator* Store(MachineType rep, WriteBarrierKind kind) {
     StoreRepresentation store_rep = {rep, kind};
     OP1(Store, StoreRepresentation, store_rep, Operator::kNoRead, 3, 0);
   }
 
@@ skipping 41 matching lines @@
   Operator* Int64Add() { BINOP_AC(Int64Add); }
   Operator* Int64Sub() { BINOP(Int64Sub); }
   Operator* Int64Mul() { BINOP_AC(Int64Mul); }
   Operator* Int64Div() { BINOP(Int64Div); }
   Operator* Int64UDiv() { BINOP(Int64UDiv); }
   Operator* Int64Mod() { BINOP(Int64Mod); }
   Operator* Int64UMod() { BINOP(Int64UMod); }
   Operator* Int64LessThan() { BINOP(Int64LessThan); }
   Operator* Int64LessThanOrEqual() { BINOP(Int64LessThanOrEqual); }
 
+  // Signed comparison of word-sized integer values, translates to int32/int64
+  // comparisons depending on the word-size of the machine.
+  Operator* IntLessThan() { INT_SIZE(LessThan); }
+  Operator* IntLessThanOrEqual() { INT_SIZE(LessThanOrEqual); }
+
   // Convert representation of integers between float64 and int32/uint32.
   // The precise rounding mode and handling of out of range inputs are *not*
   // defined for these operators, since they are intended only for use with
   // integers.
   Operator* ChangeInt32ToFloat64() { UNOP(ChangeInt32ToFloat64); }
   Operator* ChangeUint32ToFloat64() { UNOP(ChangeUint32ToFloat64); }
   Operator* ChangeFloat64ToInt32() { UNOP(ChangeFloat64ToInt32); }
   Operator* ChangeFloat64ToUint32() { UNOP(ChangeFloat64ToUint32); }
 
   // Sign/zero extend int32/uint32 to int64/uint64.
@@ skipping 16 matching lines @@
   // Floating point comparisons complying to IEEE 754.
   Operator* Float64Equal() { BINOP_C(Float64Equal); }
   Operator* Float64LessThan() { BINOP(Float64LessThan); }
   Operator* Float64LessThanOrEqual() { BINOP(Float64LessThanOrEqual); }
 
   inline bool is32() const { return word_ == kRepWord32; }
   inline bool is64() const { return word_ == kRepWord64; }
   inline MachineType word() const { return word_; }
 
 #undef WORD_SIZE
+#undef INT_SIZE
 #undef UNOP
 #undef BINOP
 #undef OP1
 #undef SIMPLE
 
  private:
   Zone* zone_;
   MachineType word_;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_MACHINE_OPERATOR_H_