[cleanup] Port KeyedLoadIC_{Slow,Miss} to TF and drop unused IC handler code

src/ic/handler-compiler.h

 // Copyright 2014 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_IC_HANDLER_COMPILER_H_
 #define V8_IC_HANDLER_COMPILER_H_
 
 #include "src/ic/access-compiler.h"
 #include "src/ic/ic-state.h"
 
@@ skipping 22 matching lines @@
                                   Label* miss, ReturnHolder return_what) {
     UNREACHABLE();
     return receiver();
   }
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss) { UNREACHABLE(); }
 
   // Frontend loads from receiver(), returns holder register which may be
   // different.
   Register Frontend(Handle<Name> name);
-  void NonexistentFrontendHeader(Handle<Name> name, Label* miss,
-                                 Register scratch1, Register scratch2);
 
   // When FLAG_vector_ics is true, handlers that have the possibility of missing
   // will need to save and pass these to miss handlers.
   void PushVectorAndSlot() { PushVectorAndSlot(vector(), slot()); }
   void PushVectorAndSlot(Register vector, Register slot);
   void PopVectorAndSlot() { PopVectorAndSlot(vector(), slot()); }
   void PopVectorAndSlot(Register vector, Register slot);
 
   void DiscardVectorAndSlot();
 
-  void PushReturnAddress(Register tmp);
-  void PopReturnAddress(Register tmp);
-
   // TODO(verwaest): Make non-static.
   static void GenerateApiAccessorCall(MacroAssembler* masm,
                                       const CallOptimization& optimization,
                                       Handle<Map> receiver_map,
                                       Register receiver, Register scratch,
                                       bool is_store, Register store_parameter,
                                       Register accessor_holder,
                                       int accessor_index);
 
   // Helper function used to check that the dictionary doesn't contain
@@ skipping 78 matching lines @@
   // the iterator points to a LookupIterator::PROPERTY, its access will be
   // inlined.
   Handle<Code> CompileLoadInterceptor(LookupIterator* it);
 
   Handle<Code> CompileLoadViaGetter(Handle<Name> name, int accessor_index,
                                     int expected_arguments);
 
   Handle<Code> CompileLoadGlobal(Handle<PropertyCell> cell, Handle<Name> name,
                                  bool is_configurable);
 
-  // Static interface
-  static Handle<Code> ComputeLoadNonexistent(Handle<Name> name,
-                                             Handle<Map> map);
-
   static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<Map> map,
                                     Register receiver, Register holder,
                                     int accessor_index, int expected_arguments,
                                     Register scratch);
 
   static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) {
     GenerateLoadViaGetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1,
                           no_reg);
   }
 
@@ skipping 12 matching lines @@
   static const int kInterceptorArgsHolderIndex = 2;
   static const int kInterceptorArgsLength = 3;
 
  protected:
   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
                                   Label* miss, ReturnHolder return_what);
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss);
 
  private:
-  Handle<Code> CompileLoadNonexistent(Handle<Name> name);
-  void GenerateLoadConstant(Handle<Object> value);
   void GenerateLoadCallback(Register reg, Handle<AccessorInfo> callback);
-  void GenerateLoadCallback(const CallOptimization& call_optimization,
-                            Handle<Map> receiver_map);
 
   // Helper emits no code if vector-ics are disabled.
   void InterceptorVectorSlotPush(Register holder_reg);
   enum PopMode { POP, DISCARD };
   void InterceptorVectorSlotPop(Register holder_reg, PopMode mode = POP);
 
   void GenerateLoadInterceptor(Register holder_reg);
   void GenerateLoadInterceptorWithFollowup(LookupIterator* it,
                                            Register holder_reg);
   void GenerateLoadPostInterceptor(LookupIterator* it, Register reg);
 
-  // Generates prototype loading code that uses the objects from the
-  // context we were in when this function was called. If the context
-  // has changed, a jump to miss is performed. This ties the generated
-  // code to a particular context and so must not be used in cases
-  // where the generated code is not allowed to have references to
-  // objects from a context.
-  static void GenerateDirectLoadGlobalFunctionPrototype(MacroAssembler* masm,
-                                                        int index,
-                                                        Register prototype,
-                                                        Label* miss);
-
   Register scratch3() { return registers_[4]; }
 };
 
 
 class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
  public:
   // All store handlers use StoreWithVectorDescriptor calling convention.
   typedef StoreWithVectorDescriptor Descriptor;
 
   explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<Map> map,
@@ skipping 32 matching lines @@
   }
 
  protected:
   virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
                                   Label* miss, ReturnHolder return_what);
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss);
   void GenerateRestoreName(Label* label, Handle<Name> name);
 
  private:
-  void GenerateRestoreName(Handle<Name> name);
-  void GenerateRestoreMap(Handle<Map> transition, Register map_reg,
-                          Register scratch, Label* miss);
-
-  void GenerateConstantCheck(Register map_reg, int descriptor,
-                             Register value_reg, Register scratch,
-                             Label* miss_label);
-
-  bool RequiresFieldTypeChecks(FieldType* field_type) const;
-  void GenerateFieldTypeChecks(FieldType* field_type, Register value_reg,
-                               Label* miss_label);
-
   static Register value();
 };
 
 
 class ElementHandlerCompiler : public PropertyHandlerCompiler {
  public:
   explicit ElementHandlerCompiler(Isolate* isolate)
       : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC,
                                 Handle<Map>::null(), Handle<JSObject>::null(),
                                 kCacheOnReceiver) {}
 
   virtual ~ElementHandlerCompiler() {}
 
   static Handle<Object> GetKeyedLoadHandler(Handle<Map> receiver_map,
                                             Isolate* isolate);
   void CompileElementHandlers(MapHandleList* receiver_maps,
                               List<Handle<Object>>* handlers);
 };
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_IC_HANDLER_COMPILER_H_