[cleanup] Drop handwritten KeyedStoreIC code

src/arm64/macro-assembler-arm64.h

 // 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.
 
 #ifndef V8_ARM64_MACRO_ASSEMBLER_ARM64_H_
 #define V8_ARM64_MACRO_ASSEMBLER_ARM64_H_
 
 #include <vector>
 
 #include "src/arm64/assembler-arm64.h"
@@ skipping 1548 matching lines @@
                        Label* fall_through);
 
   // Test the bits of register defined by bit_pattern, and branch to
   // if_any_set, if_all_clear or fall_through accordingly.
   void TestAndSplit(const Register& reg,
                     uint64_t bit_pattern,
                     Label* if_all_clear,
                     Label* if_any_set,
                     Label* fall_through);
 
-  // Check if a map for a JSObject indicates that the object can have both smi
-  // and HeapObject elements.  Jump to the specified label if it does not.
-  void CheckFastObjectElements(Register map, Register scratch, Label* fail);
-
-  // Check to see if number can be stored as a double in FastDoubleElements.
-  // If it can, store it at the index specified by key_reg in the array,
-  // otherwise jump to fail.
-  void StoreNumberToDoubleElements(Register value_reg,
-                                   Register key_reg,
-                                   Register elements_reg,
-                                   Register scratch1,
-                                   FPRegister fpscratch1,
-                                   Label* fail,
-                                   int elements_offset = 0);
-
   // ---------------------------------------------------------------------------
   // Inline caching support.
 
   void EmitSeqStringSetCharCheck(Register string,
                                  Register index,
                                  SeqStringSetCharCheckIndexType index_type,
                                  Register scratch,
                                  uint32_t encoding_mask);
 
   // Hash the interger value in 'key' register.
@@ skipping 23 matching lines @@
   // AllocationMemento object that can be checked for in order to pretransition
   // to another type.
   // On entry, receiver should point to the array object.
   // If allocation info is present, the Z flag is set (so that the eq
   // condition will pass).
   void TestJSArrayForAllocationMemento(Register receiver,
                                        Register scratch1,
                                        Register scratch2,
                                        Label* no_memento_found);
 
-  void JumpIfJSArrayHasAllocationMemento(Register receiver,
-                                         Register scratch1,
-                                         Register scratch2,
-                                         Label* memento_found) {
-    Label no_memento_found;
-    TestJSArrayForAllocationMemento(receiver, scratch1, scratch2,
-                                    &no_memento_found);
-    B(eq, memento_found);
-    Bind(&no_memento_found);
-  }
-
   // The stack pointer has to switch between csp and jssp when setting up and
   // destroying the exit frame. Hence preserving/restoring the registers is
   // slightly more complicated than simple push/pop operations.
   void ExitFramePreserveFPRegs();
   void ExitFrameRestoreFPRegs();
 
   // Generates function and stub prologue code.
   void StubPrologue(StackFrame::Type type, int frame_slots);
   void Prologue(bool code_pre_aging);
 
@@ skipping 247 matching lines @@
   // If emit_debug_code() is false, this emits no code.
   void AssertIsString(const Register& object);
 
   // Like Assert(), but always enabled.
   void Check(Condition cond, BailoutReason reason);
   void CheckRegisterIsClear(Register reg, BailoutReason reason);
 
   // Print a message to stderr and abort execution.
   void Abort(BailoutReason reason);
 
-  // Conditionally load the cached Array transitioned map of type
-  // transitioned_kind from the native context if the map in register
-  // map_in_out is the cached Array map in the native context of
-  // expected_kind.
-  void LoadTransitionedArrayMapConditional(
-      ElementsKind expected_kind,
-      ElementsKind transitioned_kind,
-      Register map_in_out,
-      Register scratch1,
-      Register scratch2,
-      Label* no_map_match);
-
   void LoadNativeContextSlot(int index, Register dst);
 
   // Load the initial map from the global function. The registers function and
   // map can be the same, function is then overwritten.
   void LoadGlobalFunctionInitialMap(Register function,
                                     Register map,
                                     Register scratch);
 
   CPURegList* TmpList() { return &tmp_list_; }
   CPURegList* FPTmpList() { return &fptmp_list_; }
@@ skipping 68 matching lines @@
   static void EmitCodeAgeSequence(Assembler* assm, Code* stub);
 
   // Call EmitCodeAgeSequence from a MacroAssembler context.
   void EmitCodeAgeSequence(Code* stub);
 
   // Return true if the sequence is a young sequence geneated by
   // EmitFrameSetupForCodeAgePatching. Otherwise, this method asserts that the
   // sequence is a code age sequence (emitted by EmitCodeAgeSequence).
   static bool IsYoungSequence(Isolate* isolate, byte* sequence);
 
-  // Jumps to found label if a prototype map has dictionary elements.
-  void JumpIfDictionaryInPrototypeChain(Register object, Register scratch0,
-                                        Register scratch1, Label* found);
-
   // Perform necessary maintenance operations before a push or after a pop.
   //
   // Note that size is specified in bytes.
   void PushPreamble(Operand total_size);
   void PopPostamble(Operand total_size);
 
   void PushPreamble(int count, int size) { PushPreamble(count * size); }
   void PopPostamble(int count, int size) { PopPostamble(count * size); }
 
  private:
@@ skipping 252 matching lines @@
   class RegisterBits : public BitField<unsigned, 0, 5> {};
   class DeltaBits : public BitField<uint32_t, 5, 32-5> {};
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #define ACCESS_MASM(masm) masm->
 
 #endif  // V8_ARM64_MACRO_ASSEMBLER_ARM64_H_