Clean up IC tracing for CallICs.

src/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 145 matching lines @@
     code->VerifyEmbeddedObjectsDependency();
 #endif
     SetTargetAtAddress(address(), code, constant_pool());
     target_set_ = true;
   }
 
   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,
                                 Handle<Object> key);
   MaybeHandle<Object> ReferenceError(const char* type, Handle<String> 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,
@@ skipping 152 matching lines @@
   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) {
     }
 
-    InlineCacheState GetICState() const { return ::v8::internal::GENERIC; }
-
     ExtraICState GetExtraICState() const;
 
     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> {};
 
     const int argc_;
     const CallType call_type_;
   };
 
   explicit CallIC(Isolate* isolate)
       : IC(EXTRA_CALL_FRAME, isolate) {
   }
 
-  void PatchMegamorphic(Handle<FixedArray> vector, Handle<Smi> slot);
+  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);
 
   // Returns true if a custom handler was installed.
   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,
                                       CallType call_type);
 
   static void Clear(Isolate* isolate, Address address, Code* target,
                     ConstantPoolArray* constant_pool);
 
  private:
-  void UpdateTypeFeedbackInfo(Object* old_feedback, Object* new_feedback);
-  inline IC::State FeedbackObjectToState(Object* feedback) const;
+  inline IC::State FeedbackToState(Handle<FixedArray> vector,
+                                   Handle<Smi> slot) const;
 };
 
 
 OStream& operator<<(OStream& os, const CallIC::State& s);
 
 
 class LoadIC: public IC {
  public:
   enum ParameterIndices {
     kReceiverIndex,
@@ skipping 642 matching lines @@
 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);
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_IC_H_