[strong] Refactor ObjectStrength into a replacement for strong boolean args

src/arm64/code-stubs-arm64.cc

 // 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.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM64
 
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 189 matching lines @@
   __ Pop(scratch2, scratch1);
   __ Ret();
 }
 
 
 // See call site for description.
 static void EmitIdenticalObjectComparison(MacroAssembler* masm, Register left,
                                           Register right, Register scratch,
                                           FPRegister double_scratch,
                                           Label* slow, Condition cond,
-                                          bool strong) {
+                                          Strength strength) {
   DCHECK(!AreAliased(left, right, scratch));
   Label not_identical, return_equal, heap_number;
   Register result = x0;
 
   __ Cmp(right, left);
   __ B(ne, &not_identical);
 
   // Test for NaN. Sadly, we can't just compare to factory::nan_value(),
   // so we do the second best thing - test it ourselves.
   // They are both equal and they are not both Smis so both of them are not
   // Smis.  If it's not a heap number, then return equal.
   Register right_type = scratch;
   if ((cond == lt) || (cond == gt)) {
     // Call runtime on identical JSObjects.  Otherwise return equal.
     __ JumpIfObjectType(right, right_type, right_type, FIRST_SPEC_OBJECT_TYPE,
                         slow, ge);
     // Call runtime on identical symbols since we need to throw a TypeError.
     __ Cmp(right_type, SYMBOL_TYPE);
     __ B(eq, slow);
-    if (strong) {
+    if (is_strong(strength)) {
       // Call the runtime on anything that is converted in the semantics, since
       // we need to throw a TypeError. Smis have already been ruled out.
       __ Cmp(right_type, Operand(HEAP_NUMBER_TYPE));
       __ B(eq, &return_equal);
       __ Tst(right_type, Operand(kIsNotStringMask));
       __ B(ne, slow);
     }
   } else if (cond == eq) {
     __ JumpIfHeapNumber(right, &heap_number);
   } else {
     __ JumpIfObjectType(right, right_type, right_type, HEAP_NUMBER_TYPE,
                         &heap_number);
     // Comparing JS objects with <=, >= is complicated.
     __ Cmp(right_type, FIRST_SPEC_OBJECT_TYPE);
     __ B(ge, slow);
     // Call runtime on identical symbols since we need to throw a TypeError.
     __ Cmp(right_type, SYMBOL_TYPE);
     __ B(eq, slow);
-    if (strong) {
+    if (is_strong(strength)) {
       // Call the runtime on anything that is converted in the semantics,
       // since we need to throw a TypeError. Smis and heap numbers have
       // already been ruled out.
       __ Tst(right_type, Operand(kIsNotStringMask));
       __ B(ne, slow);
     }
     // Normally here we fall through to return_equal, but undefined is
     // special: (undefined == undefined) == true, but
     // (undefined <= undefined) == false!  See ECMAScript 11.8.5.
     if ((cond == le) || (cond == ge)) {
@@ skipping 262 matching lines @@
   __ Sub(result, lhs, Operand::UntagSmi(rhs));
   __ Ret();
 
   __ Bind(&not_two_smis);
 
   // NOTICE! This code is only reached after a smi-fast-case check, so it is
   // certain that at least one operand isn't a smi.
 
   // Handle the case where the objects are identical. Either returns the answer
   // or goes to slow. Only falls through if the objects were not identical.
-  EmitIdenticalObjectComparison(masm, lhs, rhs, x10, d0, &slow, cond, strong());
+  EmitIdenticalObjectComparison(masm, lhs, rhs, x10, d0, &slow, cond,
+                                strength());
 
   // If either is a smi (we know that at least one is not a smi), then they can
   // only be strictly equal if the other is a HeapNumber.
   __ JumpIfBothNotSmi(lhs, rhs, &not_smis);
 
   // Exactly one operand is a smi. EmitSmiNonsmiComparison generates code that
   // can:
   //  1) Return the answer.
   //  2) Branch to the slow case.
   //  3) Fall through to both_loaded_as_doubles.
@@ skipping 98 matching lines @@
   }
 
   __ Bind(&slow);
 
   __ Push(lhs, rhs);
   // Figure out which native to call and setup the arguments.
   Builtins::JavaScript native;
   if (cond == eq) {
     native = strict() ? Builtins::STRICT_EQUALS : Builtins::EQUALS;
   } else {
-    native = strong() ? Builtins::COMPARE_STRONG : Builtins::COMPARE;
+    native =
+        is_strong(strength()) ? Builtins::COMPARE_STRONG : Builtins::COMPARE;
     int ncr;  // NaN compare result
     if ((cond == lt) || (cond == le)) {
       ncr = GREATER;
     } else {
       DCHECK((cond == gt) || (cond == ge));  // remaining cases
       ncr = LESS;
     }
     __ Mov(x10, Smi::FromInt(ncr));
     __ Push(x10);
   }
@@ skipping 2833 matching lines @@
 
   __ Bind(&values_in_d_regs);
   __ Fcmp(lhs_d, rhs_d);
   __ B(vs, &unordered);  // Overflow flag set if either is NaN.
   STATIC_ASSERT((LESS == -1) && (EQUAL == 0) && (GREATER == 1));
   __ Cset(result, gt);  // gt => 1, otherwise (lt, eq) => 0 (EQUAL).
   __ Csinv(result, result, xzr, ge);  // lt => -1, gt => 1, eq => 0.
   __ Ret();
 
   __ Bind(&unordered);
-  CompareICStub stub(isolate(), op(), strong(), CompareICState::GENERIC,
+  CompareICStub stub(isolate(), op(), strength(), CompareICState::GENERIC,
                      CompareICState::GENERIC, CompareICState::GENERIC);
   __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
 
   __ Bind(&maybe_undefined1);
   if (Token::IsOrderedRelationalCompareOp(op())) {
     __ JumpIfNotRoot(rhs, Heap::kUndefinedValueRootIndex, &miss);
     __ JumpIfSmi(lhs, &unordered);
     __ JumpIfNotHeapNumber(lhs, &maybe_undefined2);
     __ B(&unordered);
   }
@@ skipping 2313 matching lines @@
                            MemOperand(fp, 6 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64