Minor-key-ify four stubs.

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 495 matching lines @@
 }
 
 
 void ICCompareStub::GenerateGeneric(MacroAssembler* masm) {
   Register lhs = x1;
   Register rhs = x0;
   Register result = x0;
   Condition cond = GetCondition();
 
   Label miss;
-  ICCompareStub_CheckInputType(masm, lhs, x2, left_, &miss);
-  ICCompareStub_CheckInputType(masm, rhs, x3, right_, &miss);
+  ICCompareStub_CheckInputType(masm, lhs, x2, left(), &miss);
+  ICCompareStub_CheckInputType(masm, rhs, x3, right(), &miss);
 
   Label slow;  // Call builtin.
   Label not_smis, both_loaded_as_doubles;
   Label not_two_smis, smi_done;
   __ JumpIfEitherNotSmi(lhs, rhs, &not_two_smis);
   __ SmiUntag(lhs);
   __ Sub(result, lhs, Operand::UntagSmi(rhs));
   __ Ret();
 
   __ Bind(&not_two_smis);
@@ skipping 2669 matching lines @@
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
 void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
   // Inputs are in x0 (lhs) and x1 (rhs).
-  DCHECK(state_ == CompareIC::SMI);
+  DCHECK(state() == CompareIC::SMI);
   ASM_LOCATION("ICCompareStub[Smis]");
   Label miss;
   // Bail out (to 'miss') unless both x0 and x1 are smis.
   __ JumpIfEitherNotSmi(x0, x1, &miss);
 
   if (GetCondition() == eq) {
     // For equality we do not care about the sign of the result.
     __ Sub(x0, x0, x1);
   } else {
     // Untag before subtracting to avoid handling overflow.
     __ SmiUntag(x1);
     __ Sub(x0, x1, Operand::UntagSmi(x0));
   }
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateNumbers(MacroAssembler* masm) {
-  DCHECK(state_ == CompareIC::NUMBER);
+  DCHECK(state() == CompareIC::NUMBER);
   ASM_LOCATION("ICCompareStub[HeapNumbers]");
 
   Label unordered, maybe_undefined1, maybe_undefined2;
   Label miss, handle_lhs, values_in_d_regs;
   Label untag_rhs, untag_lhs;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
   FPRegister rhs_d = d0;
   FPRegister lhs_d = d1;
 
-  if (left_ == CompareIC::SMI) {
+  if (left() == CompareIC::SMI) {
     __ JumpIfNotSmi(lhs, &miss);
   }
-  if (right_ == CompareIC::SMI) {
+  if (right() == CompareIC::SMI) {
     __ JumpIfNotSmi(rhs, &miss);
   }
 
   __ SmiUntagToDouble(rhs_d, rhs, kSpeculativeUntag);
   __ SmiUntagToDouble(lhs_d, lhs, kSpeculativeUntag);
 
   // Load rhs if it's a heap number.
   __ JumpIfSmi(rhs, &handle_lhs);
   __ CheckMap(rhs, x10, Heap::kHeapNumberMapRootIndex, &maybe_undefined1,
               DONT_DO_SMI_CHECK);
   __ Ldr(rhs_d, FieldMemOperand(rhs, HeapNumber::kValueOffset));
 
   // Load lhs if it's a heap number.
   __ Bind(&handle_lhs);
   __ JumpIfSmi(lhs, &values_in_d_regs);
   __ CheckMap(lhs, x10, Heap::kHeapNumberMapRootIndex, &maybe_undefined2,
               DONT_DO_SMI_CHECK);
   __ Ldr(lhs_d, FieldMemOperand(lhs, HeapNumber::kValueOffset));
 
   __ 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);
-  ICCompareStub stub(isolate(), op_, CompareIC::GENERIC, CompareIC::GENERIC,
+  ICCompareStub stub(isolate(), op(), CompareIC::GENERIC, CompareIC::GENERIC,
                      CompareIC::GENERIC);
   __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
 
   __ Bind(&maybe_undefined1);
-  if (Token::IsOrderedRelationalCompareOp(op_)) {
+  if (Token::IsOrderedRelationalCompareOp(op())) {
     __ JumpIfNotRoot(rhs, Heap::kUndefinedValueRootIndex, &miss);
     __ JumpIfSmi(lhs, &unordered);
     __ JumpIfNotObjectType(lhs, x10, x10, HEAP_NUMBER_TYPE, &maybe_undefined2);
     __ B(&unordered);
   }
 
   __ Bind(&maybe_undefined2);
-  if (Token::IsOrderedRelationalCompareOp(op_)) {
+  if (Token::IsOrderedRelationalCompareOp(op())) {
     __ JumpIfRoot(lhs, Heap::kUndefinedValueRootIndex, &unordered);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateInternalizedStrings(MacroAssembler* masm) {
-  DCHECK(state_ == CompareIC::INTERNALIZED_STRING);
+  DCHECK(state() == CompareIC::INTERNALIZED_STRING);
   ASM_LOCATION("ICCompareStub[InternalizedStrings]");
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(lhs, rhs, &miss);
 
@@ skipping 17 matching lines @@
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateUniqueNames(MacroAssembler* masm) {
-  DCHECK(state_ == CompareIC::UNIQUE_NAME);
+  DCHECK(state() == CompareIC::UNIQUE_NAME);
   ASM_LOCATION("ICCompareStub[UniqueNames]");
   DCHECK(GetCondition() == eq);
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   Register lhs_instance_type = w2;
   Register rhs_instance_type = w3;
@@ skipping 18 matching lines @@
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateStrings(MacroAssembler* masm) {
-  DCHECK(state_ == CompareIC::STRING);
+  DCHECK(state() == CompareIC::STRING);
   ASM_LOCATION("ICCompareStub[Strings]");
 
   Label miss;
 
-  bool equality = Token::IsEqualityOp(op_);
+  bool equality = Token::IsEqualityOp(op());
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(rhs, lhs, &miss);
 
   // Check that both operands are strings.
   Register rhs_map = x10;
@@ skipping 55 matching lines @@
   } else {
     __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void ICCompareStub::GenerateObjects(MacroAssembler* masm) {
-  DCHECK(state_ == CompareIC::OBJECT);
+  DCHECK(state() == CompareIC::OBJECT);
   ASM_LOCATION("ICCompareStub[Objects]");
 
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   __ JumpIfEitherSmi(rhs, lhs, &miss);
 
@@ skipping 49 matching lines @@
     ExternalReference miss =
       ExternalReference(IC_Utility(IC::kCompareIC_Miss), isolate());
 
     FrameScope scope(masm, StackFrame::INTERNAL);
     Register op = x10;
     Register left = x1;
     Register right = x0;
     // Preserve some caller-saved registers.
     __ Push(x1, x0, lr);
     // Push the arguments.
-    __ Mov(op, Smi::FromInt(op_));
+    __ Mov(op, Smi::FromInt(this->op()));
     __ Push(left, right, op);
 
     // Call the miss handler. This also pops the arguments.
     __ CallExternalReference(miss, 3);
 
     // Compute the entry point of the rewritten stub.
     __ Add(stub_entry, x0, Code::kHeaderSize - kHeapObjectTag);
     // Restore caller-saved registers.
     __ Pop(lr, x0, x1);
   }
@@ skipping 1605 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64