Clean up code stubs and ensure distinct major keys.

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 465 matching lines @@
   Register left_bitfield = left_type;
   __ Ldrb(right_bitfield, FieldMemOperand(right_map, Map::kBitFieldOffset));
   __ Ldrb(left_bitfield, FieldMemOperand(left_map, Map::kBitFieldOffset));
   __ And(result, right_bitfield, left_bitfield);
   __ And(result, result, 1 << Map::kIsUndetectable);
   __ Eor(result, result, 1 << Map::kIsUndetectable);
   __ Ret();
 }
 
 
-static void ICCompareStub_CheckInputType(MacroAssembler* masm,
-                                         Register input,
+static void CompareICStub_CheckInputType(MacroAssembler* masm, Register input,
                                          Register scratch,
                                          CompareIC::State expected,
                                          Label* fail) {
   Label ok;
   if (expected == CompareIC::SMI) {
     __ JumpIfNotSmi(input, fail);
   } else if (expected == CompareIC::NUMBER) {
     __ JumpIfSmi(input, &ok);
     __ CheckMap(input, scratch, Heap::kHeapNumberMapRootIndex, fail,
                 DONT_DO_SMI_CHECK);
   }
   // We could be strict about internalized/non-internalized here, but as long as
   // hydrogen doesn't care, the stub doesn't have to care either.
   __ Bind(&ok);
 }
 
 
-void ICCompareStub::GenerateGeneric(MacroAssembler* masm) {
+void CompareICStub::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);
+  CompareICStub_CheckInputType(masm, lhs, x2, left(), &miss);
+  CompareICStub_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 2666 matching lines @@
   __ Push(code_);
   __ CallRuntime(Runtime::kCharFromCode, 1);
   __ Mov(result_, x0);
   call_helper.AfterCall(masm);
   __ B(&exit_);
 
   __ Abort(kUnexpectedFallthroughFromCharFromCodeSlowCase);
 }
 
 
-void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
+void CompareICStub::GenerateSmis(MacroAssembler* masm) {
   // Inputs are in x0 (lhs) and x1 (rhs).
   DCHECK(state() == CompareIC::SMI);
-  ASM_LOCATION("ICCompareStub[Smis]");
+  ASM_LOCATION("CompareICStub[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) {
+void CompareICStub::GenerateNumbers(MacroAssembler* masm) {
   DCHECK(state() == CompareIC::NUMBER);
-  ASM_LOCATION("ICCompareStub[HeapNumbers]");
+  ASM_LOCATION("CompareICStub[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;
@@ skipping 23 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);
-  ICCompareStub stub(isolate(), op(), CompareIC::GENERIC, CompareIC::GENERIC,
+  CompareICStub stub(isolate(), op(), CompareIC::GENERIC, CompareIC::GENERIC,
                      CompareIC::GENERIC);
   __ Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
 
   __ Bind(&maybe_undefined1);
   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())) {
     __ JumpIfRoot(lhs, Heap::kUndefinedValueRootIndex, &unordered);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateInternalizedStrings(MacroAssembler* masm) {
+void CompareICStub::GenerateInternalizedStrings(MacroAssembler* masm) {
   DCHECK(state() == CompareIC::INTERNALIZED_STRING);
-  ASM_LOCATION("ICCompareStub[InternalizedStrings]");
+  ASM_LOCATION("CompareICStub[InternalizedStrings]");
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   // Check that both operands are heap objects.
   __ JumpIfEitherSmi(lhs, rhs, &miss);
 
   // Check that both operands are internalized strings.
@@ skipping 15 matching lines @@
   STATIC_ASSERT(EQUAL == 0);
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateUniqueNames(MacroAssembler* masm) {
+void CompareICStub::GenerateUniqueNames(MacroAssembler* masm) {
   DCHECK(state() == CompareIC::UNIQUE_NAME);
-  ASM_LOCATION("ICCompareStub[UniqueNames]");
+  ASM_LOCATION("CompareICStub[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 16 matching lines @@
   STATIC_ASSERT(EQUAL == 0);
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateStrings(MacroAssembler* masm) {
+void CompareICStub::GenerateStrings(MacroAssembler* masm) {
   DCHECK(state() == CompareIC::STRING);
-  ASM_LOCATION("ICCompareStub[Strings]");
+  ASM_LOCATION("CompareICStub[Strings]");
 
   Label miss;
 
   bool equality = Token::IsEqualityOp(op());
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   // Check that both operands are heap objects.
@@ skipping 57 matching lines @@
     __ TailCallRuntime(Runtime::kStringEquals, 2, 1);
   } else {
     __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
   }
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateObjects(MacroAssembler* masm) {
+void CompareICStub::GenerateObjects(MacroAssembler* masm) {
   DCHECK(state() == CompareIC::OBJECT);
-  ASM_LOCATION("ICCompareStub[Objects]");
+  ASM_LOCATION("CompareICStub[Objects]");
 
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   __ JumpIfEitherSmi(rhs, lhs, &miss);
 
   __ JumpIfNotObjectType(rhs, x10, x10, JS_OBJECT_TYPE, &miss);
   __ JumpIfNotObjectType(lhs, x10, x10, JS_OBJECT_TYPE, &miss);
 
   DCHECK(GetCondition() == eq);
   __ Sub(result, rhs, lhs);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
-void ICCompareStub::GenerateKnownObjects(MacroAssembler* masm) {
-  ASM_LOCATION("ICCompareStub[KnownObjects]");
+void CompareICStub::GenerateKnownObjects(MacroAssembler* masm) {
+  ASM_LOCATION("CompareICStub[KnownObjects]");
 
   Label miss;
 
   Register result = x0;
   Register rhs = x0;
   Register lhs = x1;
 
   __ JumpIfEitherSmi(rhs, lhs, &miss);
 
   Register rhs_map = x10;
   Register lhs_map = x11;
   __ Ldr(rhs_map, FieldMemOperand(rhs, HeapObject::kMapOffset));
   __ Ldr(lhs_map, FieldMemOperand(lhs, HeapObject::kMapOffset));
   __ Cmp(rhs_map, Operand(known_map_));
   __ B(ne, &miss);
   __ Cmp(lhs_map, Operand(known_map_));
   __ B(ne, &miss);
 
   __ Sub(result, rhs, lhs);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
 
 // This method handles the case where a compare stub had the wrong
 // implementation. It calls a miss handler, which re-writes the stub. All other
-// ICCompareStub::Generate* methods should fall back into this one if their
+// CompareICStub::Generate* methods should fall back into this one if their
 // operands were not the expected types.
-void ICCompareStub::GenerateMiss(MacroAssembler* masm) {
-  ASM_LOCATION("ICCompareStub[Miss]");
+void CompareICStub::GenerateMiss(MacroAssembler* masm) {
+  ASM_LOCATION("CompareICStub[Miss]");
 
   Register stub_entry = x11;
   {
     ExternalReference miss =
       ExternalReference(IC_Utility(IC::kCompareIC_Miss), isolate());
 
     FrameScope scope(masm, StackFrame::INTERNAL);
     Register op = x10;
     Register left = x1;
     Register right = x0;
@@ skipping 1599 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64