Introduce extra IC state to record additional feedback from IC-s.

src/stub-cache.h

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 159 matching lines @@
   // ---
 
   MUST_USE_RESULT static MaybeObject* ComputeCallField(int argc,
                                                        InLoopFlag in_loop,
                                                        Code::Kind,
                                                        String* name,
                                                        Object* object,
                                                        JSObject* holder,
                                                        int index);
 
-  MUST_USE_RESULT static MaybeObject* ComputeCallConstant(int argc,
-                                                          InLoopFlag in_loop,
-                                                          Code::Kind,
-                                                          String* name,
-                                                          Object* object,
-                                                          JSObject* holder,
-                                                          JSFunction* function);
+  MUST_USE_RESULT static MaybeObject* ComputeCallConstant(
+      int argc,
+      InLoopFlag in_loop,
+      Code::Kind,
+      Code::ExtraICState extra_ic_state,
+      String* name,
+      Object* object,
+      JSObject* holder,
+      JSFunction* function);
 
   MUST_USE_RESULT static MaybeObject* ComputeCallNormal(int argc,
                                                         InLoopFlag in_loop,
                                                         Code::Kind,
                                                         String* name,
                                                         JSObject* receiver);
 
   MUST_USE_RESULT static MaybeObject* ComputeCallInterceptor(int argc,
                                                              Code::Kind,
                                                              String* name,
@@ skipping 26 matching lines @@
       Code::Kind kind);
 
   MUST_USE_RESULT static MaybeObject* ComputeCallNormal(int argc,
                                                         InLoopFlag in_loop,
                                                         Code::Kind kind);
 
   MUST_USE_RESULT static MaybeObject* ComputeCallMegamorphic(int argc,
                                                              InLoopFlag in_loop,
                                                              Code::Kind kind);
 
-  MUST_USE_RESULT static MaybeObject* ComputeCallMiss(int argc,
-                                                      Code::Kind kind);
+  MUST_USE_RESULT static MaybeObject* ComputeCallMiss(
+      int argc,
+      Code::Kind kind,
+      Code::ExtraICState extra_ic_state);
 
   // Finds the Code object stored in the Heap::non_monomorphic_cache().
   MUST_USE_RESULT static Code* FindCallInitialize(int argc,
                                                   InLoopFlag in_loop,
                                                   Code::Kind kind);
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   MUST_USE_RESULT static MaybeObject* ComputeCallDebugBreak(int argc,
                                                             Code::Kind kind);
 
@@ skipping 408 matching lines @@
   V(StringFromCharCode)                         \
   V(MathFloor)                                  \
   V(MathAbs)
 
 
 class CallStubCompiler: public StubCompiler {
  public:
   CallStubCompiler(int argc,
                    InLoopFlag in_loop,
                    Code::Kind kind,
+                   Code::ExtraICState extra_ic_state,
                    InlineCacheHolderFlag cache_holder);
 
   MUST_USE_RESULT MaybeObject* CompileCallField(JSObject* object,
                                                 JSObject* holder,
                                                 int index,
                                                 String* name);
   MUST_USE_RESULT MaybeObject* CompileCallConstant(Object* object,
                                                    JSObject* holder,
                                                    JSFunction* function,
                                                    String* name,
@@ skipping 25 matching lines @@
                                                    JSObject* holder,           \
                                                    JSGlobalPropertyCell* cell, \
                                                    JSFunction* function,       \
                                                    String* fname);
   CUSTOM_CALL_IC_GENERATORS(DECLARE_CALL_GENERATOR)
 #undef DECLARE_CALL_GENERATOR
 
   const ParameterCount arguments_;
   const InLoopFlag in_loop_;
   const Code::Kind kind_;
+  const Code::ExtraICState extra_ic_state_;
   const InlineCacheHolderFlag cache_holder_;
 
   const ParameterCount& arguments() { return arguments_; }
 
   MUST_USE_RESULT MaybeObject* GetCode(PropertyType type, String* name);
 
   // Convenience function. Calls GetCode above passing
   // CONSTANT_FUNCTION type and the name of the given function.
   MUST_USE_RESULT MaybeObject* GetCode(JSFunction* function);
 
   void GenerateNameCheck(String* name, Label* miss);
 
   void GenerateGlobalReceiverCheck(JSObject* object,
                                    JSObject* holder,
                                    String* name,
                                    Label* miss);
 
   // Generates code to load the function from the cell checking that
   // it still contains the same function.
   void GenerateLoadFunctionFromCell(JSGlobalPropertyCell* cell,
                                     JSFunction* function,
                                     Label* miss);
 
   // Generates a jump to CallIC miss stub. Returns Failure if the jump cannot
   // be generated.
   MUST_USE_RESULT MaybeObject* GenerateMissBranch();
+  MUST_USE_RESULT MaybeObject* GenerateExtraStateChangeBranch(
+      Code::ExtraICState new_extra_ic_state);
+
+  MUST_USE_RESULT MaybeObject* GenerateBranchHelper(
+      Code::ExtraICState extra_ic_state);
 };
 
 
 class ConstructStubCompiler: public StubCompiler {
  public:
   explicit ConstructStubCompiler() {}
 
   MUST_USE_RESULT MaybeObject* CompileConstructStub(JSFunction* function);
 
  private:
@@ skipping 45 matching lines @@
 
   JSFunction* constant_function_;
   bool is_simple_api_call_;
   FunctionTemplateInfo* expected_receiver_type_;
   CallHandlerInfo* api_call_info_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_