Enable constant pool support.

src/ic/ic.h

Index: src/ic/ic.h
diff --git a/src/ic/ic.h b/src/ic/ic.h
index 4da6e7ceccf5453f447339c627c6013ac3c6d405..50777814ac4cd5425e8b160e6471e65625cf82c8 100644
--- a/src/ic/ic.h
+++ b/src/ic/ic.h
@@ -77,8 +77,7 @@ class IC {
   }
 
   // Clear the inline cache to initial state.
-  static void Clear(Isolate* isolate, Address address,
-                    ConstantPoolArray* constant_pool);
+  static void Clear(Isolate* isolate, Address address, Address constant_pool);
 
 #ifdef DEBUG
   bool IsLoadStub() const {
@@ -168,9 +167,9 @@ class IC {
 
   // Access the target code for the given IC address.
   static inline Code* GetTargetAtAddress(Address address,
-                                         ConstantPoolArray* constant_pool);
+                                         Address constant_pool);
   static inline void SetTargetAtAddress(Address address, Code* target,
-                                        ConstantPoolArray* constant_pool);
+                                        Address constant_pool);
   static void OnTypeFeedbackChanged(Isolate* isolate, Address address,
                                     State old_state, State new_state,
                                     bool target_remains_ic_stub);
@@ -254,8 +253,9 @@ class IC {
 
  private:
   inline Code* raw_target() const;
-  inline ConstantPoolArray* constant_pool() const;
-  inline ConstantPoolArray* raw_constant_pool() const;
+  inline Address constant_pool() const;
+  inline void set_raw_constant_pool(Address* constant_pool, Isolate* isolate);
+  inline Address raw_constant_pool() const;
 
   void FindTargetMaps() {
     if (target_maps_set_) return;
@@ -285,7 +285,10 @@ class IC {
 
   // The constant pool of the code which originally called the IC (which might
   // be for the breakpointed copy of the original code).
-  Handle<ConstantPoolArray> raw_constant_pool_;
+  union {
+    Address* raw_constant_pool_;
+    Handle<ConstantPoolArray> raw_constant_pool_handle_;
+  };

[rmcilroy, 2015/04/08 12:38:55]

let's not make this a union. I'm not sure that storing this as a raw address is
OK - what if a GC happens in the middle of the IC handling and the code object
movede, then this address will point to the wrong location.  

[MTBrandyberry, 2015/05/07 20:38:32]

This address is the stack slot holding the constant pool pointer -- not the
constant pool pointer itself (providing a level of indirection just like
pc_address_).  I will make this more clear.

 
   // The original code target that missed.
   Handle<Code> target_;
@@ -436,7 +439,7 @@ class LoadIC : public IC {
   Handle<Code> SimpleFieldLoad(FieldIndex index);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+                    Address constant_pool);
 
   friend class IC;
 };
@@ -500,7 +503,7 @@ class KeyedLoadIC : public LoadIC {
 
  private:
   static void Clear(Isolate* isolate, Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+                    Address constant_pool);
 
   friend class IC;
 };
@@ -578,7 +581,7 @@ class StoreIC : public IC {
   inline void set_target(Code* code);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+                    Address constant_pool);
 
   friend class IC;
 };
@@ -665,7 +668,7 @@ class KeyedStoreIC : public StoreIC {
   }
 
   static void Clear(Isolate* isolate, Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+                    Address constant_pool);
 
   KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver,
                                     Handle<Object> key, Handle<Object> value);
@@ -713,7 +716,7 @@ class CompareIC : public IC {
   static Code* GetRawUninitialized(Isolate* isolate, Token::Value op);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+                    Address constant_pool);
 
   Token::Value op_;
 
@@ -729,8 +732,7 @@ class CompareNilIC : public IC {
 
   static Handle<Code> GetUninitialized();
 
-  static void Clear(Address address, Code* target,
-                    ConstantPoolArray* constant_pool);
+  static void Clear(Address address, Code* target, Address constant_pool);
 
   static Handle<Object> DoCompareNilSlow(Isolate* isolate, NilValue nil,
                                          Handle<Object> object);