Move IC code into a subdir and move ic-compilation related code from stub-cache into ic-compiler

src/ic/ic.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_IC_H_
 #define V8_IC_H_
 
 #include "src/macro-assembler.h"
 
 namespace v8 {
@@ skipping 26 matching lines @@
   ICU(CompareNilIC_Miss)               \
   ICU(Unreachable)                     \
   ICU(ToBooleanIC_Miss)
 //
 // IC is the base class for LoadIC, StoreIC, KeyedLoadIC, and KeyedStoreIC.
 //
 class IC {
  public:
   // The ids for utility called from the generated code.
   enum UtilityId {
-  #define CONST_NAME(name) k##name,
+#define CONST_NAME(name) k##name,
     IC_UTIL_LIST(CONST_NAME)
-  #undef CONST_NAME
+#undef CONST_NAME
     kUtilityCount
   };
 
   // Looks up the address of the named utility.
   static Address AddressFromUtilityId(UtilityId id);
 
   // Alias the inline cache state type to make the IC code more readable.
   typedef InlineCacheState State;
 
   // The IC code is either invoked with no extra frames on the stack
   // or with a single extra frame for supporting calls.
-  enum FrameDepth {
-    NO_EXTRA_FRAME = 0,
-    EXTRA_CALL_FRAME = 1
-  };
+  enum FrameDepth { NO_EXTRA_FRAME = 0, EXTRA_CALL_FRAME = 1 };
 
   // Construct the IC structure with the given number of extra
   // JavaScript frames on the stack.
   IC(FrameDepth depth, Isolate* isolate);
   virtual ~IC() {}
 
   State state() const { return state_; }
   inline Address address() const;
 
   // Compute the current IC state based on the target stub, receiver and name.
   void UpdateState(Handle<Object> receiver, Handle<Object> name);
 
   bool IsNameCompatibleWithPrototypeFailure(Handle<Object> name);
   void MarkPrototypeFailure(Handle<Object> name) {
     DCHECK(IsNameCompatibleWithPrototypeFailure(name));
     state_ = PROTOTYPE_FAILURE;
   }
 
   // If the stub contains weak maps then this function adds the stub to
   // the dependent code array of each weak map.
   static void RegisterWeakMapDependency(Handle<Code> stub);
 
   // This function is called when a weak map in the stub is dying,
   // invalidates the stub by setting maps in it to undefined.
   static void InvalidateMaps(Code* stub);
 
   // Clear the inline cache to initial state.
-  static void Clear(Isolate* isolate,
-                    Address address,
+  static void Clear(Isolate* isolate, Address address,
                     ConstantPoolArray* constant_pool);
 
 #ifdef DEBUG
   bool IsLoadStub() const {
     return target()->is_load_stub() || target()->is_keyed_load_stub();
   }
 
   bool IsStoreStub() const {
     return target()->is_store_stub() || target()->is_keyed_store_stub();
   }
 
-  bool IsCallStub() const {
-    return target()->is_call_stub();
-  }
+  bool IsCallStub() const { return target()->is_call_stub(); }
 #endif
 
   template <class TypeClass>
   static JSFunction* GetRootConstructor(TypeClass* type,
                                         Context* native_context);
   static inline Handle<Map> GetHandlerCacheHolder(HeapType* type,
                                                   bool receiver_is_holder,
                                                   Isolate* isolate,
                                                   CacheHolderFlag* flag);
   static inline Handle<Map> GetICCacheHolder(HeapType* type, Isolate* isolate,
@@ skipping 26 matching lines @@
   Isolate* isolate() const { return isolate_; }
 
   // Get the shared function info of the caller.
   SharedFunctionInfo* GetSharedFunctionInfo() const;
   // Get the code object of the caller.
   Code* GetCode() const;
   // Get the original (non-breakpointed) code object of the caller.
   Code* GetOriginalCode() const;
 
   // Set the call-site target.
-  void set_target(Code* code) {
-#ifdef VERIFY_HEAP
-    code->VerifyEmbeddedObjectsDependency();
-#endif
-    SetTargetAtAddress(address(), code, constant_pool());
-    target_set_ = true;
-  }
-
+  inline void set_target(Code* code);
   bool is_target_set() { return target_set_; }
 
   char TransitionMarkFromState(IC::State state);
   void TraceIC(const char* type, Handle<Object> name);
   void TraceIC(const char* type, Handle<Object> name, State old_state,
                State new_state);
 
-  MaybeHandle<Object> TypeError(const char* type,
-                                Handle<Object> object,
+  MaybeHandle<Object> TypeError(const char* type, Handle<Object> object,
                                 Handle<Object> key);
   MaybeHandle<Object> ReferenceError(const char* type, Handle<Name> name);
 
   // Access the target code for the given IC address.
   static inline Code* GetTargetAtAddress(Address address,
                                          ConstantPoolArray* constant_pool);
-  static inline void SetTargetAtAddress(Address address,
-                                        Code* target,
+  static inline void SetTargetAtAddress(Address address, Code* target,
                                         ConstantPoolArray* constant_pool);
   static void OnTypeFeedbackChanged(Isolate* isolate, Address address,
                                     State old_state, State new_state,
                                     bool target_remains_ic_stub);
   static void PostPatching(Address address, Code* target, Code* old_target);
 
   // Compute the handler either by compiling or by retrieving a cached version.
   Handle<Code> ComputeHandler(LookupIterator* lookup,
                               Handle<Object> value = Handle<Code>::null());
   virtual Handle<Code> CompileHandler(LookupIterator* lookup,
@@ skipping 19 matching lines @@
   }
   virtual Handle<Code> megamorphic_stub() {
     UNREACHABLE();
     return Handle<Code>::null();
   }
 
   bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
                                               Handle<String> name);
 
   ExtraICState extra_ic_state() const { return extra_ic_state_; }
-  void set_extra_ic_state(ExtraICState state) {
-    extra_ic_state_ = state;
-  }
+  void set_extra_ic_state(ExtraICState state) { extra_ic_state_ = state; }
 
   Handle<HeapType> receiver_type() { return receiver_type_; }
   void update_receiver_type(Handle<Object> receiver) {
     receiver_type_ = CurrentTypeOf(receiver, isolate_);
   }
 
   void TargetMaps(MapHandleList* list) {
     FindTargetMaps();
     for (int i = 0; i < target_maps_.length(); i++) {
       list->Add(target_maps_.at(i));
     }
   }
 
   void TargetTypes(TypeHandleList* list) {
     FindTargetMaps();
     for (int i = 0; i < target_maps_.length(); i++) {
       list->Add(IC::MapToType<HeapType>(target_maps_.at(i), isolate_));
     }
   }
 
   Map* FirstTargetMap() {
     FindTargetMaps();
     return target_maps_.length() > 0 ? *target_maps_.at(0) : NULL;
   }
 
  protected:
-  void UpdateTarget() {
-    target_ = handle(raw_target(), isolate_);
-  }
+  inline void UpdateTarget();
 
  private:
-  Code* raw_target() const {
-    return GetTargetAtAddress(address(), constant_pool());
-  }
+  inline Code* raw_target() const;
   inline ConstantPoolArray* constant_pool() const;
   inline ConstantPoolArray* raw_constant_pool() const;
 
   void FindTargetMaps() {
     if (target_maps_set_) return;
     target_maps_set_ = true;
     if (state_ == MONOMORPHIC) {
       Map* map = target_->FindFirstMap();
       if (map != NULL) target_maps_.Add(handle(map));
     } else if (state_ != UNINITIALIZED && state_ != PREMONOMORPHIC) {
@@ skipping 30 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(IC);
 };
 
 
 // An IC_Utility encapsulates IC::UtilityId. It exists mainly because you
 // cannot make forward declarations to an enum.
 class IC_Utility {
  public:
   explicit IC_Utility(IC::UtilityId id)
-    : address_(IC::AddressFromUtilityId(id)), id_(id) {}
+      : address_(IC::AddressFromUtilityId(id)), id_(id) {}
 
   Address address() const { return address_; }
 
   IC::UtilityId id() const { return id_; }
+
  private:
   Address address_;
   IC::UtilityId id_;
 };
 
 
-class CallIC: public IC {
+class CallIC : public IC {
  public:
   enum CallType { METHOD, FUNCTION };
 
   class State V8_FINAL BASE_EMBEDDED {
    public:
     explicit State(ExtraICState extra_ic_state);
 
-    State(int argc, CallType call_type)
-        : argc_(argc), call_type_(call_type) {
-    }
+    State(int argc, CallType call_type) : argc_(argc), call_type_(call_type) {}
 
     ExtraICState GetExtraICState() const;
 
-    static void GenerateAheadOfTime(
-        Isolate*, void (*Generate)(Isolate*, const State&));
+    static void GenerateAheadOfTime(Isolate*,
+                                    void (*Generate)(Isolate*, const State&));
 
     int arg_count() const { return argc_; }
     CallType call_type() const { return call_type_; }
 
     bool CallAsMethod() const { return call_type_ == METHOD; }
 
    private:
-    class ArgcBits: public BitField<int, 0, Code::kArgumentsBits> {};
-    class CallTypeBits: public BitField<CallType, Code::kArgumentsBits, 1> {};
+    class ArgcBits : public BitField<int, 0, Code::kArgumentsBits> {};
+    class CallTypeBits : public BitField<CallType, Code::kArgumentsBits, 1> {};
 
     const int argc_;
     const CallType call_type_;
   };
 
-  explicit CallIC(Isolate* isolate)
-      : IC(EXTRA_CALL_FRAME, isolate) {
-  }
+  explicit CallIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
 
   void PatchMegamorphic(Handle<Object> function, Handle<FixedArray> vector,
                         Handle<Smi> slot);
 
-  void HandleMiss(Handle<Object> receiver,
-                  Handle<Object> function,
-                  Handle<FixedArray> vector,
-                  Handle<Smi> slot);
+  void HandleMiss(Handle<Object> receiver, Handle<Object> function,
+                  Handle<FixedArray> vector, Handle<Smi> slot);
 
   // Returns true if a custom handler was installed.
-  bool DoCustomHandler(Handle<Object> receiver,
-                       Handle<Object> function,
-                       Handle<FixedArray> vector,
-                       Handle<Smi> slot,
+  bool DoCustomHandler(Handle<Object> receiver, Handle<Object> function,
+                       Handle<FixedArray> vector, Handle<Smi> slot,
                        const State& state);
 
   // Code generator routines.
-  static Handle<Code> initialize_stub(Isolate* isolate,
-                                      int argc,
+  static Handle<Code> initialize_stub(Isolate* isolate, int argc,
                                       CallType call_type);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
  private:
   inline IC::State FeedbackToState(Handle<FixedArray> vector,
                                    Handle<Smi> slot) const;
 };
 
 
 OStream& operator<<(OStream& os, const CallIC::State& s);
 
 
-class LoadIC: public IC {
+class LoadIC : public IC {
  public:
-  enum ParameterIndices {
-    kReceiverIndex,
-    kNameIndex,
-    kParameterCount
-  };
+  enum ParameterIndices { kReceiverIndex, kNameIndex, kParameterCount };
   static const Register ReceiverRegister();
   static const Register NameRegister();
 
   // With flag vector-ics, there is an additional argument. And for calls from
   // crankshaft, yet another.
   static const Register SlotRegister();
   static const Register VectorRegister();
 
   class State V8_FINAL BASE_EMBEDDED {
    public:
-    explicit State(ExtraICState extra_ic_state)
-        : state_(extra_ic_state) {}
+    explicit State(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
 
     explicit State(ContextualMode mode)
         : state_(ContextualModeBits::encode(mode)) {}
 
     ExtraICState GetExtraICState() const { return state_; }
 
     ContextualMode contextual_mode() const {
       return ContextualModeBits::decode(state_);
     }
 
    private:
-    class ContextualModeBits: public BitField<ContextualMode, 0, 1> {};
+    class ContextualModeBits : public BitField<ContextualMode, 0, 1> {};
     STATIC_ASSERT(static_cast<int>(NOT_CONTEXTUAL) == 0);
 
     const ExtraICState state_;
   };
 
   static ExtraICState ComputeExtraICState(ContextualMode contextual_mode) {
     return State(contextual_mode).GetExtraICState();
   }
 
   static ContextualMode GetContextualMode(ExtraICState state) {
     return State(state).contextual_mode();
   }
 
   ContextualMode contextual_mode() const {
     return GetContextualMode(extra_ic_state());
   }
 
-  explicit LoadIC(FrameDepth depth, Isolate* isolate)
-      : IC(depth, isolate) {
+  explicit LoadIC(FrameDepth depth, Isolate* isolate) : IC(depth, isolate) {
     DCHECK(IsLoadStub());
   }
 
   // Returns if this IC is for contextual (no explicit receiver)
   // access to properties.
   bool IsUndeclaredGlobal(Handle<Object> receiver) {
     if (receiver->IsGlobalObject()) {
       return contextual_mode() == CONTEXTUAL;
     } else {
       DCHECK(contextual_mode() != CONTEXTUAL);
@@ skipping 11 matching lines @@
   static void GenerateNormal(MacroAssembler* masm);
   static void GenerateRuntimeGetProperty(MacroAssembler* masm);
 
   static Handle<Code> initialize_stub(Isolate* isolate,
                                       ExtraICState extra_state);
 
   MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
                                            Handle<Name> name);
 
  protected:
-  void set_target(Code* code) {
-    // The contextual mode must be preserved across IC patching.
-    DCHECK(GetContextualMode(code->extra_ic_state()) ==
-           GetContextualMode(target()->extra_ic_state()));
-
-    IC::set_target(code);
-  }
+  inline void set_target(Code* code);
 
   Handle<Code> slow_stub() const {
     if (kind() == Code::LOAD_IC) {
       return isolate()->builtins()->LoadIC_Slow();
     } else {
       DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
       return isolate()->builtins()->KeyedLoadIC_Slow();
     }
   }
 
   virtual Handle<Code> megamorphic_stub();
 
   // Update the inline cache and the global stub cache based on the
   // lookup result.
   void UpdateCaches(LookupIterator* lookup);
 
   virtual Handle<Code> CompileHandler(LookupIterator* lookup,
                                       Handle<Object> unused,
                                       CacheHolderFlag cache_holder);
 
  private:
   virtual Handle<Code> pre_monomorphic_stub() const;
   static Handle<Code> pre_monomorphic_stub(Isolate* isolate,
                                            ExtraICState extra_state);
 
   Handle<Code> SimpleFieldLoad(FieldIndex index);
 
-  static void Clear(Isolate* isolate,
-                    Address address,
-                    Code* target,
+  static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   friend class IC;
 };
 
 
-class KeyedLoadIC: public LoadIC {
+class KeyedLoadIC : public LoadIC {
  public:
   explicit KeyedLoadIC(FrameDepth depth, Isolate* isolate)
       : LoadIC(depth, isolate) {
     DCHECK(target()->is_keyed_load_stub());
   }
 
   MUST_USE_RESULT MaybeHandle<Object> Load(Handle<Object> object,
                                            Handle<Object> key);
 
   // Code generator routines.
@@ skipping 29 matching lines @@
   Handle<Code> indexed_interceptor_stub() {
     return isolate()->builtins()->KeyedLoadIC_IndexedInterceptor();
   }
   Handle<Code> sloppy_arguments_stub() {
     return isolate()->builtins()->KeyedLoadIC_SloppyArguments();
   }
   Handle<Code> string_stub() {
     return isolate()->builtins()->KeyedLoadIC_String();
   }
 
-  static void Clear(Isolate* isolate,
-                    Address address,
-                    Code* target,
+  static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   friend class IC;
 };
 
 
-class StoreIC: public IC {
+class StoreIC : public IC {
  public:
-  class StrictModeState: public BitField<StrictMode, 1, 1> {};
+  class StrictModeState : public BitField<StrictMode, 1, 1> {};
   static ExtraICState ComputeExtraICState(StrictMode flag) {
     return StrictModeState::encode(flag);
   }
   static StrictMode GetStrictMode(ExtraICState state) {
     return StrictModeState::decode(state);
   }
 
   // For convenience, a statically declared encoding of strict mode extra
   // IC state.
-  static const ExtraICState kStrictModeState =
-      1 << StrictModeState::kShift;
+  static const ExtraICState kStrictModeState = 1 << StrictModeState::kShift;
 
   enum ParameterIndices {
     kReceiverIndex,
     kNameIndex,
     kValueIndex,
     kParameterCount
   };
   static const Register ReceiverRegister();
   static const Register NameRegister();
   static const Register ValueRegister();
 
-  StoreIC(FrameDepth depth, Isolate* isolate)
-      : IC(depth, isolate) {
+  StoreIC(FrameDepth depth, Isolate* isolate) : IC(depth, isolate) {
     DCHECK(IsStoreStub());
   }
 
   StrictMode strict_mode() const {
     return StrictModeState::decode(extra_ic_state());
   }
 
   // Code generators for stub routines. Only called once at startup.
   static void GenerateSlow(MacroAssembler* masm);
   static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
   static void GeneratePreMonomorphic(MacroAssembler* masm) {
     GenerateMiss(masm);
   }
   static void GenerateMiss(MacroAssembler* masm);
   static void GenerateMegamorphic(MacroAssembler* masm);
   static void GenerateNormal(MacroAssembler* masm);
   static void GenerateRuntimeSetProperty(MacroAssembler* masm,
                                          StrictMode strict_mode);
 
-  static Handle<Code> initialize_stub(Isolate* isolate,
-                                      StrictMode strict_mode);
+  static Handle<Code> initialize_stub(Isolate* isolate, StrictMode strict_mode);
 
   MUST_USE_RESULT MaybeHandle<Object> Store(
-      Handle<Object> object,
-      Handle<Name> name,
-      Handle<Object> value,
+      Handle<Object> object, Handle<Name> name, Handle<Object> value,
       JSReceiver::StoreFromKeyed store_mode =
           JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED);
 
   bool LookupForWrite(LookupIterator* it, Handle<Object> value,
                       JSReceiver::StoreFromKeyed store_mode);
 
  protected:
   virtual Handle<Code> megamorphic_stub();
 
   // Stub accessors.
@@ skipping 12 matching lines @@
 
   // Update the inline cache and the global stub cache based on the
   // lookup result.
   void UpdateCaches(LookupIterator* lookup, Handle<Object> value,
                     JSReceiver::StoreFromKeyed store_mode);
   virtual Handle<Code> CompileHandler(LookupIterator* lookup,
                                       Handle<Object> value,
                                       CacheHolderFlag cache_holder);
 
  private:
-  void set_target(Code* code) {
-    // Strict mode must be preserved across IC patching.
-    DCHECK(GetStrictMode(code->extra_ic_state()) ==
-           GetStrictMode(target()->extra_ic_state()));
-    IC::set_target(code);
-  }
+  inline void set_target(Code* code);
 
-  static void Clear(Isolate* isolate,
-                    Address address,
-                    Code* target,
+  static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   friend class IC;
 };
 
 
-enum KeyedStoreCheckMap {
-  kDontCheckMap,
-  kCheckMap
-};
+enum KeyedStoreCheckMap { kDontCheckMap, kCheckMap };
 
 
-enum KeyedStoreIncrementLength {
-  kDontIncrementLength,
-  kIncrementLength
-};
+enum KeyedStoreIncrementLength { kDontIncrementLength, kIncrementLength };
 
 
-class KeyedStoreIC: public StoreIC {
+class KeyedStoreIC : public StoreIC {
  public:
   // ExtraICState bits (building on IC)
   // ExtraICState bits
-  class ExtraICStateKeyedAccessStoreMode:
-      public BitField<KeyedAccessStoreMode, 2, 4> {};  // NOLINT
+  class ExtraICStateKeyedAccessStoreMode
+      : public BitField<KeyedAccessStoreMode, 2, 4> {};  // NOLINT
 
   static ExtraICState ComputeExtraICState(StrictMode flag,
                                           KeyedAccessStoreMode mode) {
     return StrictModeState::encode(flag) |
-        ExtraICStateKeyedAccessStoreMode::encode(mode);
+           ExtraICStateKeyedAccessStoreMode::encode(mode);
   }
 
   static KeyedAccessStoreMode GetKeyedAccessStoreMode(
       ExtraICState extra_state) {
     return ExtraICStateKeyedAccessStoreMode::decode(extra_state);
   }
 
   // The map register isn't part of the normal call specification, but
   // ElementsTransitionAndStoreStub, used in polymorphic keyed store
   // stub implementations requires it to be initialized.
   static const Register MapRegister();
 
-  KeyedStoreIC(FrameDepth depth, Isolate* isolate)
-      : StoreIC(depth, isolate) {
+  KeyedStoreIC(FrameDepth depth, Isolate* isolate) : StoreIC(depth, isolate) {
     DCHECK(target()->is_keyed_store_stub());
   }
 
   MUST_USE_RESULT MaybeHandle<Object> Store(Handle<Object> object,
                                             Handle<Object> name,
                                             Handle<Object> value);
 
   // Code generators for stub routines.  Only called once at startup.
   static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); }
   static void GeneratePreMonomorphic(MacroAssembler* masm) {
@@ skipping 26 matching lines @@
       return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
     } else {
       return isolate()->builtins()->KeyedStoreIC_Generic();
     }
   }
 
   Handle<Code> StoreElementStub(Handle<JSObject> receiver,
                                 KeyedAccessStoreMode store_mode);
 
  private:
-  void set_target(Code* code) {
-    // Strict mode must be preserved across IC patching.
-    DCHECK(GetStrictMode(code->extra_ic_state()) == strict_mode());
-    IC::set_target(code);
-  }
+  inline void set_target(Code* code);
 
   // Stub accessors.
   virtual Handle<Code> generic_stub() const {
     if (strict_mode() == STRICT) {
       return isolate()->builtins()->KeyedStoreIC_Generic_Strict();
     } else {
       return isolate()->builtins()->KeyedStoreIC_Generic();
     }
   }
 
   Handle<Code> sloppy_arguments_stub() {
     return isolate()->builtins()->KeyedStoreIC_SloppyArguments();
   }
 
-  static void Clear(Isolate* isolate,
-                    Address address,
-                    Code* target,
+  static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver,
-                                    Handle<Object> key,
-                                    Handle<Object> value);
+                                    Handle<Object> key, Handle<Object> value);
 
   Handle<Map> ComputeTransitionedMap(Handle<Map> map,
                                      KeyedAccessStoreMode store_mode);
 
   friend class IC;
 };
 
 
 // Mode to overwrite BinaryExpression values.
 enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
 
 // Type Recording BinaryOpIC, that records the types of the inputs and outputs.
-class BinaryOpIC: public IC {
+class BinaryOpIC : public IC {
  public:
   class State V8_FINAL BASE_EMBEDDED {
    public:
     State(Isolate* isolate, ExtraICState extra_ic_state);
 
     State(Isolate* isolate, Token::Value op, OverwriteMode mode)
-        : op_(op), mode_(mode), left_kind_(NONE), right_kind_(NONE),
-          result_kind_(NONE), isolate_(isolate) {
+        : op_(op),
+          mode_(mode),
+          left_kind_(NONE),
+          right_kind_(NONE),
+          result_kind_(NONE),
+          isolate_(isolate) {
       DCHECK_LE(FIRST_TOKEN, op);
       DCHECK_LE(op, LAST_TOKEN);
     }
 
     InlineCacheState GetICState() const {
       if (Max(left_kind_, right_kind_) == NONE) {
         return ::v8::internal::UNINITIALIZED;
       }
       if (Max(left_kind_, right_kind_) == GENERIC) {
         return ::v8::internal::MEGAMORPHIC;
       }
       if (Min(left_kind_, right_kind_) == GENERIC) {
         return ::v8::internal::GENERIC;
       }
       return ::v8::internal::MONOMORPHIC;
     }
 
     ExtraICState GetExtraICState() const;
 
-    static void GenerateAheadOfTime(
-        Isolate*, void (*Generate)(Isolate*, const State&));
+    static void GenerateAheadOfTime(Isolate*,
+                                    void (*Generate)(Isolate*, const State&));
 
     bool CanReuseDoubleBox() const {
       return (result_kind_ > SMI && result_kind_ <= NUMBER) &&
-          ((mode_ == OVERWRITE_LEFT &&
-            left_kind_ > SMI && left_kind_ <= NUMBER) ||
-           (mode_ == OVERWRITE_RIGHT &&
-            right_kind_ > SMI && right_kind_ <= NUMBER));
+             ((mode_ == OVERWRITE_LEFT && left_kind_ > SMI &&
+               left_kind_ <= NUMBER) ||
+              (mode_ == OVERWRITE_RIGHT && right_kind_ > SMI &&
+               right_kind_ <= NUMBER));
     }
 
     // Returns true if the IC _could_ create allocation mementos.
     bool CouldCreateAllocationMementos() const {
       if (left_kind_ == STRING || right_kind_ == STRING) {
         DCHECK_EQ(Token::ADD, op_);
         return true;
       }
       return false;
     }
 
     // Returns true if the IC _should_ create allocation mementos.
     bool ShouldCreateAllocationMementos() const {
       return FLAG_allocation_site_pretenuring &&
-          CouldCreateAllocationMementos();
+             CouldCreateAllocationMementos();
     }
 
     bool HasSideEffects() const {
       return Max(left_kind_, right_kind_) == GENERIC;
     }
 
     // Returns true if the IC should enable the inline smi code (i.e. if either
     // parameter may be a smi).
     bool UseInlinedSmiCode() const {
       return KindMaybeSmi(left_kind_) || KindMaybeSmi(right_kind_);
     }
 
     static const int FIRST_TOKEN = Token::BIT_OR;
     static const int LAST_TOKEN = Token::MOD;
 
     Token::Value op() const { return op_; }
     OverwriteMode mode() const { return mode_; }
     Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
 
-    Type* GetLeftType(Zone* zone) const {
-      return KindToType(left_kind_, zone);
-    }
+    Type* GetLeftType(Zone* zone) const { return KindToType(left_kind_, zone); }
     Type* GetRightType(Zone* zone) const {
       return KindToType(right_kind_, zone);
     }
     Type* GetResultType(Zone* zone) const;
 
-    void Update(Handle<Object> left,
-                Handle<Object> right,
+    void Update(Handle<Object> left, Handle<Object> right,
                 Handle<Object> result);
 
     Isolate* isolate() const { return isolate_; }
 
    private:
     friend OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
 
     enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
 
     Kind UpdateKind(Handle<Object> object, Kind kind) const;
 
     static const char* KindToString(Kind kind);
     static Type* KindToType(Kind kind, Zone* zone);
     static bool KindMaybeSmi(Kind kind) {
       return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
     }
 
     // We truncate the last bit of the token.
     STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
-    class OpField:                 public BitField<int, 0, 4> {};
-    class OverwriteModeField:      public BitField<OverwriteMode, 4, 2> {};
-    class ResultKindField:         public BitField<Kind, 6, 3> {};
-    class LeftKindField:           public BitField<Kind, 9,  3> {};
+    class OpField : public BitField<int, 0, 4> {};
+    class OverwriteModeField : public BitField<OverwriteMode, 4, 2> {};
+    class ResultKindField : public BitField<Kind, 6, 3> {};
+    class LeftKindField : public BitField<Kind, 9, 3> {};
     // When fixed right arg is set, we don't need to store the right kind.
     // Thus the two fields can overlap.
-    class HasFixedRightArgField:   public BitField<bool, 12, 1> {};
-    class FixedRightArgValueField: public BitField<int,  13, 4> {};
-    class RightKindField:          public BitField<Kind, 13, 3> {};
+    class HasFixedRightArgField : public BitField<bool, 12, 1> {};
+    class FixedRightArgValueField : public BitField<int, 13, 4> {};
+    class RightKindField : public BitField<Kind, 13, 3> {};
 
     Token::Value op_;
     OverwriteMode mode_;
     Kind left_kind_;
     Kind right_kind_;
     Kind result_kind_;
     Maybe<int> fixed_right_arg_;
     Isolate* isolate_;
   };
 
-  explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) { }
+  explicit BinaryOpIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
 
   static Builtins::JavaScript TokenToJSBuiltin(Token::Value op);
 
   MaybeHandle<Object> Transition(Handle<AllocationSite> allocation_site,
                                  Handle<Object> left,
                                  Handle<Object> right) V8_WARN_UNUSED_RESULT;
 };
 
 
 OStream& operator<<(OStream& os, const BinaryOpIC::State& s);
 
 
-class CompareIC: public IC {
+class CompareIC : public IC {
  public:
   // The type/state lattice is defined by the following inequations:
   //   UNINITIALIZED < ...
   //   ... < GENERIC
   //   SMI < NUMBER
   //   INTERNALIZED_STRING < STRING
   //   KNOWN_OBJECT < OBJECT
   enum State {
     UNINITIALIZED,
     SMI,
     NUMBER,
     STRING,
     INTERNALIZED_STRING,
-    UNIQUE_NAME,    // Symbol or InternalizedString
-    OBJECT,         // JSObject
-    KNOWN_OBJECT,   // JSObject with specific map (faster check)
+    UNIQUE_NAME,   // Symbol or InternalizedString
+    OBJECT,        // JSObject
+    KNOWN_OBJECT,  // JSObject with specific map (faster check)
     GENERIC
   };
 
   static State NewInputState(State old_state, Handle<Object> value);
 
-  static Type* StateToType(Zone* zone,
-                           State state,
+  static Type* StateToType(Zone* zone, State state,
                            Handle<Map> map = Handle<Map>());
 
   static void StubInfoToType(uint32_t stub_key, Type** left_type,
                              Type** right_type, Type** overall_type,
                              Handle<Map> map, Zone* zone);
 
   CompareIC(Isolate* isolate, Token::Value op)
-      : IC(EXTRA_CALL_FRAME, isolate), op_(op) { }
+      : IC(EXTRA_CALL_FRAME, isolate), op_(op) {}
 
   // Update the inline cache for the given operands.
   Code* UpdateCaches(Handle<Object> x, Handle<Object> y);
 
 
   // Factory method for getting an uninitialized compare stub.
   static Handle<Code> GetUninitialized(Isolate* isolate, Token::Value op);
 
   // Helper function for computing the condition for a compare operation.
   static Condition ComputeCondition(Token::Value op);
 
   static const char* GetStateName(State state);
 
  private:
   static bool HasInlinedSmiCode(Address address);
 
-  State TargetState(State old_state,
-                    State old_left,
-                    State old_right,
-                    bool has_inlined_smi_code,
-                    Handle<Object> x,
+  State TargetState(State old_state, State old_left, State old_right,
+                    bool has_inlined_smi_code, Handle<Object> x,
                     Handle<Object> y);
 
   bool strict() const { return op_ == Token::EQ_STRICT; }
   Condition GetCondition() const { return ComputeCondition(op_); }
 
   static Code* GetRawUninitialized(Isolate* isolate, Token::Value op);
 
-  static void Clear(Isolate* isolate,
-                    Address address,
-                    Code* target,
+  static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   Token::Value op_;
 
   friend class IC;
 };
 
 
-class CompareNilIC: public IC {
+class CompareNilIC : public IC {
  public:
   explicit CompareNilIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
 
   Handle<Object> CompareNil(Handle<Object> object);
 
   static Handle<Code> GetUninitialized();
 
-  static void Clear(Address address,
-                    Code* target,
+  static void Clear(Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
   static Handle<Object> DoCompareNilSlow(Isolate* isolate, NilValue nil,
                                          Handle<Object> object);
 };
 
 
-class ToBooleanIC: public IC {
+class ToBooleanIC : public IC {
  public:
-  explicit ToBooleanIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) { }
+  explicit ToBooleanIC(Isolate* isolate) : IC(EXTRA_CALL_FRAME, isolate) {}
 
   Handle<Object> ToBoolean(Handle<Object> object);
 };
 
 
 // Helper for BinaryOpIC and CompareIC.
 enum InlinedSmiCheck { ENABLE_INLINED_SMI_CHECK, DISABLE_INLINED_SMI_CHECK };
 void PatchInlinedSmiCode(Address address, InlinedSmiCheck check);
 
 DECLARE_RUNTIME_FUNCTION(KeyedLoadIC_MissFromStubFailure);
 DECLARE_RUNTIME_FUNCTION(KeyedStoreIC_MissFromStubFailure);
 DECLARE_RUNTIME_FUNCTION(UnaryOpIC_Miss);
 DECLARE_RUNTIME_FUNCTION(StoreIC_MissFromStubFailure);
 DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss);
 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite);
 DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss);
 DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss);
 
+// Support functions for callbacks handlers.
+DECLARE_RUNTIME_FUNCTION(StoreCallbackProperty);
 
-} }  // namespace v8::internal
+// Support functions for interceptor handlers.
+DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptorOnly);
+DECLARE_RUNTIME_FUNCTION(LoadPropertyWithInterceptor);
+DECLARE_RUNTIME_FUNCTION(LoadElementWithInterceptor);
+DECLARE_RUNTIME_FUNCTION(StorePropertyWithInterceptor);
+}
+}  // namespace v8::internal
 
 #endif  // V8_IC_H_