Encapsulate type in the PropertyHandlerCompiler

src/stub-cache.h

 // Copyright 2012 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_STUB_CACHE_H_
 #define V8_STUB_CACHE_H_
 
 #include "src/allocation.h"
 #include "src/arguments.h"
 #include "src/code-stubs.h"
@@ skipping 356 matching lines @@
 };
 
 
 class PropertyHandlerCompiler : public PropertyAccessCompiler {
  public:
   static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind,
                            CacheHolderFlag cache_holder, Code::StubType type);
 
  protected:
   PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind,
-                          CacheHolderFlag cache_holder)
-      : PropertyAccessCompiler(isolate, kind, cache_holder) {}
+                          Handle<HeapType> type, CacheHolderFlag cache_holder)
+      : PropertyAccessCompiler(isolate, kind, cache_holder), type_(type) {}
 
   virtual ~PropertyHandlerCompiler() {}
 
-  virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg,
-                                  Handle<JSObject> holder, Handle<Name> name,
-                                  Label* miss) {
+  virtual Register FrontendHeader(Register object_reg, Handle<JSObject> holder,
+                                  Handle<Name> name, Label* miss) {
     UNREACHABLE();
     return receiver();
   }
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss) { UNREACHABLE(); }
 
-  Register Frontend(Handle<HeapType> type, Register object_reg,
-                    Handle<JSObject> holder, Handle<Name> name);
+  Register Frontend(Register object_reg, Handle<JSObject> holder,
+                    Handle<Name> name);
 
   // TODO(verwaest): Make non-static.
   static void GenerateFastApiCall(MacroAssembler* masm,
                                   const CallOptimization& optimization,
                                   Handle<Map> receiver_map, Register receiver,
                                   Register scratch, bool is_store, int argc,
                                   Register* values);
 
   // Helper function used to check that the dictionary doesn't contain
   // the property. This function may return false negatives, so miss_label
@@ skipping 21 matching lines @@
   // objects or doing negative lookup for slow objects, ensures that the
   // property cells for global objects are still empty) and checks that the map
   // of the holder has not changed. If necessary the function also generates
   // code for security check in case of global object holders. Helps to make
   // sure that the current IC is still valid.
   //
   // The scratch and holder registers are always clobbered, but the object
   // register is only clobbered if it the same as the holder register. The
   // function returns a register containing the holder - either object_reg or
   // holder_reg.
-  Register CheckPrototypes(Handle<HeapType> type,
-                           Register object_reg,
-                           Handle<JSObject> holder,
-                           Register holder_reg,
-                           Register scratch1,
-                           Register scratch2,
-                           Handle<Name> name,
-                           Label* miss,
+  Register CheckPrototypes(Register object_reg, Handle<JSObject> holder,
+                           Register holder_reg, Register scratch1,
+                           Register scratch2, Handle<Name> name, Label* miss,
                            PrototypeCheckType check = CHECK_ALL_MAPS);
 
   Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name);
+  void set_type_for_object(Handle<Object> object) {
+    type_ = IC::CurrentTypeOf(object, isolate());
+  }
+  Handle<HeapType> type() const { return type_; }
+
+ private:
+  Handle<HeapType> type_;
 };
 
 
 class NamedLoadHandlerCompiler : public PropertyHandlerCompiler {
  public:
-  NamedLoadHandlerCompiler(Isolate* isolate,
-                           CacheHolderFlag cache_holder = kCacheOnReceiver)
-      : PropertyHandlerCompiler(isolate, Code::LOAD_IC, cache_holder) {}
+  NamedLoadHandlerCompiler(Isolate* isolate, Handle<HeapType> type,
+                           CacheHolderFlag cache_holder)
+      : PropertyHandlerCompiler(isolate, Code::LOAD_IC, type, cache_holder) {}
 
   virtual ~NamedLoadHandlerCompiler() {}
 
-  Handle<Code> CompileLoadField(Handle<HeapType> type,
-                                Handle<JSObject> holder,
-                                Handle<Name> name,
+  Handle<Code> CompileLoadField(Handle<JSObject> holder, Handle<Name> name,
                                 FieldIndex index,
                                 Representation representation);
 
-  Handle<Code> CompileLoadCallback(Handle<HeapType> type,
-                                   Handle<JSObject> holder,
-                                   Handle<Name> name,
+  Handle<Code> CompileLoadCallback(Handle<JSObject> holder, Handle<Name> name,
                                    Handle<ExecutableAccessorInfo> callback);
 
-  Handle<Code> CompileLoadCallback(Handle<HeapType> type,
-                                   Handle<JSObject> holder,
-                                   Handle<Name> name,
+  Handle<Code> CompileLoadCallback(Handle<JSObject> holder, Handle<Name> name,
                                    const CallOptimization& call_optimization);
 
-  Handle<Code> CompileLoadConstant(Handle<HeapType> type,
-                                   Handle<JSObject> holder,
-                                   Handle<Name> name,
+  Handle<Code> CompileLoadConstant(Handle<JSObject> holder, Handle<Name> name,
                                    Handle<Object> value);
 
-  Handle<Code> CompileLoadInterceptor(Handle<HeapType> type,
-                                      Handle<JSObject> holder,
+  Handle<Code> CompileLoadInterceptor(Handle<JSObject> holder,
                                       Handle<Name> name);
 
-  Handle<Code> CompileLoadViaGetter(Handle<HeapType> type,
-                                    Handle<JSObject> holder,
-                                    Handle<Name> name,
+  Handle<Code> CompileLoadViaGetter(Handle<JSObject> holder, Handle<Name> name,
                                     Handle<JSFunction> getter);
 
+  Handle<Code> CompileLoadGlobal(Handle<GlobalObject> holder,
+                                 Handle<PropertyCell> cell, Handle<Name> name,
+                                 bool is_dont_delete);
+
   static Handle<Code> ComputeLoadNonexistent(Handle<Name> name,
                                              Handle<HeapType> type);
 
-  Handle<Code> CompileLoadGlobal(Handle<HeapType> type,
-                                 Handle<GlobalObject> holder,
-                                 Handle<PropertyCell> cell,
-                                 Handle<Name> name,
-                                 bool is_dont_delete);
-
   static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type,
                                     Register receiver,
                                     Handle<JSFunction> getter);
 
   static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) {
     GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg,
                           Handle<JSFunction>());
   }
 
   static void GenerateLoadFunctionPrototype(MacroAssembler* masm,
                                             Register receiver,
                                             Register scratch1,
                                             Register scratch2,
                                             Label* miss_label);
 
   // These constants describe the structure of the interceptor arguments on the
   // stack. The arguments are pushed by the (platform-specific)
   // PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and
   // LoadWithInterceptor.
   static const int kInterceptorArgsNameIndex = 0;
   static const int kInterceptorArgsInfoIndex = 1;
   static const int kInterceptorArgsThisIndex = 2;
   static const int kInterceptorArgsHolderIndex = 3;
   static const int kInterceptorArgsLength = 4;
 
  protected:
-  virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg,
-                                  Handle<JSObject> holder, Handle<Name> name,
-                                  Label* miss);
+  virtual Register FrontendHeader(Register object_reg, Handle<JSObject> holder,
+                                  Handle<Name> name, Label* miss);
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss);
 
  private:
-  Register CallbackFrontend(Handle<HeapType> type, Register object_reg,
-                            Handle<JSObject> holder, Handle<Name> name,
-                            Handle<Object> callback);
-  Handle<Code> CompileLoadNonexistent(Handle<HeapType> type,
-                                      Handle<JSObject> last, Handle<Name> name);
-  void NonexistentFrontend(Handle<HeapType> type, Handle<JSObject> last,
-                           Handle<Name> name);
+  Register CallbackFrontend(Register object_reg, Handle<JSObject> holder,
+                            Handle<Name> name, Handle<Object> callback);
+  Handle<Code> CompileLoadNonexistent(Handle<JSObject> last, Handle<Name> name);
+  void NonexistentFrontend(Handle<JSObject> last, Handle<Name> name);
 
   void GenerateLoadField(Register reg,
                          Handle<JSObject> holder,
                          FieldIndex field,
                          Representation representation);
   void GenerateLoadConstant(Handle<Object> value);
   void GenerateLoadCallback(Register reg,
                             Handle<ExecutableAccessorInfo> callback);
   void GenerateLoadCallback(const CallOptimization& call_optimization,
                             Handle<Map> receiver_map);
   void GenerateLoadInterceptor(Register holder_reg,
-                               Handle<Object> object,
                                Handle<JSObject> holder,
                                LookupResult* lookup,
                                Handle<Name> name);
   void GenerateLoadPostInterceptor(Register reg,
                                    Handle<JSObject> interceptor_holder,
                                    Handle<Name> name,
                                    LookupResult* lookup);
 
   // 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 scratch4() { return registers_[5]; }
 };
 
 
 class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
  public:
-  explicit NamedStoreHandlerCompiler(Isolate* isolate)
-      : PropertyHandlerCompiler(isolate, Code::STORE_IC, kCacheOnReceiver) {}
+  explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<HeapType> type)
+      : PropertyHandlerCompiler(isolate, Code::STORE_IC, type,
+                                kCacheOnReceiver) {}
 
   virtual ~NamedStoreHandlerCompiler() {}
 
   Handle<Code> CompileStoreTransition(Handle<JSObject> object,
                                       LookupResult* lookup,
                                       Handle<Map> transition,
                                       Handle<Name> name);
 
   Handle<Code> CompileStoreField(Handle<JSObject> object,
                                  LookupResult* lookup,
@@ skipping 22 matching lines @@
   static void GenerateStoreViaSetter(MacroAssembler* masm,
                                      Handle<HeapType> type, Register receiver,
                                      Handle<JSFunction> setter);
 
   static void GenerateStoreViaSetterForDeopt(MacroAssembler* masm) {
     GenerateStoreViaSetter(masm, Handle<HeapType>::null(), no_reg,
                            Handle<JSFunction>());
   }
 
  protected:
-  virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg,
-                                  Handle<JSObject> holder, Handle<Name> name,
-                                  Label* miss);
+  virtual Register FrontendHeader(Register object_reg, Handle<JSObject> holder,
+                                  Handle<Name> name, Label* miss);
 
   virtual void FrontendFooter(Handle<Name> name, Label* miss);
   void GenerateRestoreName(MacroAssembler* masm, Label* label,
                            Handle<Name> name);
 
  private:
   void GenerateStoreArrayLength();
 
   void GenerateNegativeHolderLookup(MacroAssembler* masm,
                                     Handle<JSObject> holder,
@@ skipping 35 matching lines @@
   }
 
   static Register value();
 };
 
 
 class ElementHandlerCompiler : public PropertyHandlerCompiler {
  public:
   explicit ElementHandlerCompiler(Isolate* isolate)
       : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC,
-                                kCacheOnReceiver) {}
+                                Handle<HeapType>::null(), kCacheOnReceiver) {}
 
   virtual ~ElementHandlerCompiler() {}
 
   void CompileElementHandlers(MapHandleList* receiver_maps,
                               CodeHandleList* handlers);
 
   static void GenerateLoadDictionaryElement(MacroAssembler* masm);
   static void GenerateStoreDictionaryElement(MacroAssembler* masm);
 };
 
@@ skipping 51 matching lines @@
   Handle<JSFunction> constant_function_;
   bool is_simple_api_call_;
   Handle<FunctionTemplateInfo> expected_receiver_type_;
   Handle<CallHandlerInfo> api_call_info_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_