Fix method dispatch in Keyed/StoreIC, and JumpIfNotUniqueName usage

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 3352 matching lines @@
 
   // Check that both operands are unique names. This leaves the instance
   // types loaded in tmp1 and tmp2.
   __ Ldr(x10, FieldMemOperand(lhs, HeapObject::kMapOffset));
   __ Ldr(x11, FieldMemOperand(rhs, HeapObject::kMapOffset));
   __ Ldrb(lhs_instance_type, FieldMemOperand(x10, Map::kInstanceTypeOffset));
   __ Ldrb(rhs_instance_type, FieldMemOperand(x11, Map::kInstanceTypeOffset));
 
   // To avoid a miss, each instance type should be either SYMBOL_TYPE or it
   // should have kInternalizedTag set.
-  __ JumpIfNotUniqueName(lhs_instance_type, &miss);
-  __ JumpIfNotUniqueName(rhs_instance_type, &miss);
+  __ JumpIfNotUniqueNameInstanceType(lhs_instance_type, &miss);
+  __ JumpIfNotUniqueNameInstanceType(rhs_instance_type, &miss);
 
   // Unique names are compared by identity.
   STATIC_ASSERT(EQUAL == 0);
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
@@ skipping 1096 matching lines @@
     __ Cmp(entity_name, Operand(name));
     __ B(eq, miss);
 
     Label good;
     __ JumpIfRoot(entity_name, Heap::kTheHoleValueRootIndex, &good);
 
     // Check if the entry name is not a unique name.
     __ Ldr(entity_name, FieldMemOperand(entity_name, HeapObject::kMapOffset));
     __ Ldrb(entity_name,
             FieldMemOperand(entity_name, Map::kInstanceTypeOffset));
-    __ JumpIfNotUniqueName(entity_name, miss);
+    __ JumpIfNotUniqueNameInstanceType(entity_name, miss);
     __ Bind(&good);
   }
 
   CPURegList spill_list(CPURegister::kRegister, kXRegSizeInBits, 0, 6);
   spill_list.Combine(lr);
   spill_list.Remove(scratch0);  // Scratch registers don't need to be preserved.
 
   __ PushCPURegList(spill_list);
 
   __ Ldr(x0, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
@@ skipping 66 matching lines @@
     __ B(eq, &not_in_dictionary);
 
     // Stop if found the property.
     __ Cmp(entry_key, key);
     __ B(eq, &in_dictionary);
 
     if (i != kTotalProbes - 1 && mode() == NEGATIVE_LOOKUP) {
       // Check if the entry name is not a unique name.
       __ Ldr(entry_key, FieldMemOperand(entry_key, HeapObject::kMapOffset));
       __ Ldrb(entry_key, FieldMemOperand(entry_key, Map::kInstanceTypeOffset));
-      __ JumpIfNotUniqueName(entry_key, &maybe_in_dictionary);
+      __ JumpIfNotUniqueNameInstanceType(entry_key, &maybe_in_dictionary);
     }
   }
 
   __ Bind(&maybe_in_dictionary);
   // If we are doing negative lookup then probing failure should be
   // treated as a lookup success. For positive lookup, probing failure
   // should be treated as lookup failure.
   if (mode() == POSITIVE_LOOKUP) {
     __ Mov(result, 0);
     __ Ret();
@@ skipping 483 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64