Polymorphism support for load IC.

src/ic.h

Index: src/ic.h
diff --git a/src/ic.h b/src/ic.h
index cbc3ce14dec658d165969090f8b7980337dacb73..1b4224f12080d32367d2f97170398f2c59cd3699 100644
--- a/src/ic.h
+++ b/src/ic.h
@@ -165,6 +165,16 @@ class IC {
   static inline void SetTargetAtAddress(Address address, Code* target);
   static void PostPatching(Address address, Code* target, Code* old_target);
 
+  virtual void UpdateMonomorphicIC(Handle<JSObject> receiver,
+                                   Handle<Code> handler,
+                                   Handle<String> name) {

[Jakob Kummerow, 2013/03/01 22:21:04]

I find it slightly less than ideal that we have a mix of "object, name, code"
and "object, code, name" method signatures, but I'm finding it hard to decide
which is better. The former is motivated by the purpose of the IC system being
to compute a (receiver × name → handler) function, the latter makes more sense
for helper functions taking a map list and a code list that must be exactly in
sync with each other. Maybe migrating everything to "name, object, code" would
be a compromise? In a separate clean-up CL? Or we could just leave it and worry
about more important things :-)

+    set_target(*handler);
+  }
+  bool UpdatePolymorphicIC(State state,
+                           StrictModeFlag strict_mode,
+                           Handle<JSObject> receiver,
+                           Handle<String> name,
+                           Handle<Code> code);
   void PatchCache(State state,
                   StrictModeFlag strict_mode,
                   Handle<JSObject> receiver,
@@ -377,9 +387,12 @@ class LoadIC: public IC {
                     State state,
                     Handle<Object> object,
                     Handle<String> name);
-  virtual Handle<Code> ComputeLoadMonomorphic(LookupResult* lookup,
-                                              Handle<JSObject> receiver,
-                                              Handle<String> name);
+  virtual void UpdateMonomorphicIC(Handle<JSObject> receiver,
+                                   Handle<Code> handler,
+                                   Handle<String> name);
+  virtual Handle<Code> ComputeLoadHandler(LookupResult* lookup,
+                                          Handle<JSObject> receiver,
+                                          Handle<String> name);
 
  private:
   // Stub accessors.
@@ -448,9 +461,12 @@ class KeyedLoadIC: public LoadIC {
   }
 
   // Update the inline cache.
-  virtual Handle<Code> ComputeLoadMonomorphic(LookupResult* lookup,
-                                              Handle<JSObject> receiver,
-                                              Handle<String> name);
+  virtual void UpdateMonomorphicIC(Handle<JSObject> receiver,
+                                   Handle<Code> handler,
+                                   Handle<String> name);
+  virtual Handle<Code> ComputeLoadHandler(LookupResult* lookup,
+                                          Handle<JSObject> receiver,
+                                          Handle<String> name);
   virtual void UpdateMegamorphicCache(Map* map, String* name, Code* code) { }
 
  private: