[runtime] Replace COMPARE/COMPARE_STRONG with proper Object::Compare.

src/objects.h

 // Copyright 2012 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_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/allocation.h"
@@ skipping 782 matching lines @@
   V(TRANSITION_ARRAY_SUB_TYPE)
 
 enum FixedArraySubInstanceType {
 #define DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE(name) name,
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE)
 #undef DEFINE_FIXED_ARRAY_SUB_INSTANCE_TYPE
   LAST_FIXED_ARRAY_SUB_TYPE = TRANSITION_ARRAY_SUB_TYPE
 };
 
 
+// TODO(bmeurer): Remove this in favor of the ComparisonResult below.
 enum CompareResult {
   LESS      = -1,
   EQUAL     =  0,
   GREATER   =  1,
 
   NOT_EQUAL = GREATER
 };
 
 
+// Result of an abstract relational comparison of x and y, implemented according
+// to ES6 section 7.2.11 Abstract Relational Comparison.
+enum class ComparisonResult {
+  kLessThan,     // x < y
+  kEqual,        // x = y
+  kGreaterThan,  // x > x
+  kUndefined     // at least one of x or y was undefined or NaN
+};
+
+
 #define DECL_BOOLEAN_ACCESSORS(name)   \
   inline bool name() const;            \
   inline void set_##name(bool value);  \
 
 
 #define DECL_ACCESSORS(name, type)                                      \
   inline type* name() const;                                            \
   inline void set_##name(type* value,                                   \
                          WriteBarrierMode mode = UPDATE_WRITE_BARRIER); \
 
@@ skipping 254 matching lines @@
                                            Representation representation);
 
   // Returns true if the object is of the correct type to be used as a
   // implementation of a JSObject's elements.
   inline bool HasValidElements();
 
   inline bool HasSpecificClassOf(String* name);
 
   bool BooleanValue();                                      // ECMA-262 9.2.
 
+  // ES6 section 7.2.11 Abstract Relational Comparison
+  MUST_USE_RESULT static Maybe<ComparisonResult> Compare(
+      Handle<Object> x, Handle<Object> y, Strength strength = Strength::WEAK);
+
   // ES6 section 7.2.12 Abstract Equality Comparison
   MUST_USE_RESULT static Maybe<bool> Equals(Handle<Object> x, Handle<Object> y);
 
   // ES6 section 7.2.13 Strict Equality Comparison
   bool StrictEquals(Object* that);
 
   // Convert to a JSObject if needed.
   // native_context is used when creating wrapper object.
   static inline MaybeHandle<JSReceiver> ToObject(Isolate* isolate,
                                                  Handle<Object> object);
@@ skipping 45 matching lines @@
   MUST_USE_RESULT static MaybeHandle<Object> ShiftLeft(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
   MUST_USE_RESULT static MaybeHandle<Object> ShiftRight(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
   MUST_USE_RESULT static MaybeHandle<Object> ShiftRightLogical(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
 
+  // ES6 section 12.9 Relational Operators
+  MUST_USE_RESULT static inline Maybe<bool> GreaterThan(
+      Handle<Object> x, Handle<Object> y, Strength strength = Strength::WEAK);
+  MUST_USE_RESULT static inline Maybe<bool> GreaterThanOrEqual(
+      Handle<Object> x, Handle<Object> y, Strength strength = Strength::WEAK);
+  MUST_USE_RESULT static inline Maybe<bool> LessThan(
+      Handle<Object> x, Handle<Object> y, Strength strength = Strength::WEAK);
+  MUST_USE_RESULT static inline Maybe<bool> LessThanOrEqual(
+      Handle<Object> x, Handle<Object> y, Strength strength = Strength::WEAK);
+
   // ES6 section 12.11 Binary Bitwise Operators
   MUST_USE_RESULT static MaybeHandle<Object> BitwiseAnd(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
   MUST_USE_RESULT static MaybeHandle<Object> BitwiseOr(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
   MUST_USE_RESULT static MaybeHandle<Object> BitwiseXor(
       Isolate* isolate, Handle<Object> lhs, Handle<Object> rhs,
       Strength strength = Strength::WEAK);
@@ skipping 7321 matching lines @@
   // a flat vector of char or of uc16.
   // If the string isn't flat, and therefore doesn't have flat content, the
   // returned structure will report so, and can't provide a vector of either
   // kind.
   FlatContent GetFlatContent();
 
   // Returns the parent of a sliced string or first part of a flat cons string.
   // Requires: StringShape(this).IsIndirect() && this->IsFlat()
   inline String* GetUnderlying();
 
+  // String relational comparison, implemented according to ES6 section 7.2.11
+  // Abstract Relational Comparison (step 5): The comparison of Strings uses a
+  // simple lexicographic ordering on sequences of code unit values. There is no
+  // attempt to use the more complex, semantically oriented definitions of
+  // character or string equality and collating order defined in the Unicode
+  // specification. Therefore String values that are canonically equal according
+  // to the Unicode standard could test as unequal. In effect this algorithm
+  // assumes that both Strings are already in normalized form. Also, note that
+  // for strings containing supplementary characters, lexicographic ordering on
+  // sequences of UTF-16 code unit values differs from that on sequences of code
+  // point values.
+  MUST_USE_RESULT static ComparisonResult Compare(Handle<String> x,
+                                                  Handle<String> y);
+
   // String equality operations.
   inline bool Equals(String* other);
   inline static bool Equals(Handle<String> one, Handle<String> two);
   bool IsUtf8EqualTo(Vector<const char> str, bool allow_prefix_match = false);
   bool IsOneByteEqualTo(Vector<const uint8_t> str);
   bool IsTwoByteEqualTo(Vector<const uc16> str);
 
   // Return a UTF8 representation of the string.  The string is null
   // terminated but may optionally contain nulls.  Length is returned
   // in length_output if length_output is not a null pointer  The string
@@ skipping 2020 matching lines @@
 
   Isolate* isolate_;
   Handle<FixedArray> keys_;
   Handle<OrderedHashSet> set_;
   int length_;
   DISALLOW_COPY_AND_ASSIGN(KeyAccumulator);
 };
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_