Count ICs that have type information.

src/ic.cc

 // Copyright 2012 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 278 matching lines @@
 
 
 Failure* IC::ReferenceError(const char* type, Handle<String> name) {
   HandleScope scope(isolate());
   Handle<Object> error = isolate()->factory()->NewReferenceError(
       type, HandleVector(&name, 1));
   return isolate()->Throw(*error);
 }
 
 
-void IC::PostPatching() {
-  if (FLAG_watch_ic_patching) {
+void IC::PostPatching(Address address, Code* target, Code* old_target) {
+  bool increment_ics_with_typeinfo = false;
+  if (FLAG_type_info_threshold > 0) {
+    if (old_target->is_inline_cache_stub() &&
+        target->is_inline_cache_stub()) {
+      State old_state = old_target->ic_state();
+      State new_state = target->ic_state();
+      if ((old_state == UNINITIALIZED || old_state == PREMONOMORPHIC) &&
+          (new_state != UNINITIALIZED && new_state != PREMONOMORPHIC)) {
+        increment_ics_with_typeinfo = true;
+      }
+    }
+  }
+  if (FLAG_watch_ic_patching || FLAG_type_info_threshold) {
     Isolate::Current()->runtime_profiler()->NotifyICChanged();
     // We do not want to optimize until the ICs have settled down,
     // so when they are patched, we postpone optimization for the
     // current function and the functions above it on the stack that
     // might want to inline this one.
     StackFrameIterator it;
     if (it.done()) return;
     it.Advance();
     static const int kStackFramesToMark = Compiler::kMaxInliningLevels - 1;
     for (int i = 0; i < kStackFramesToMark; ++i) {
       if (it.done()) return;
       StackFrame* raw_frame = it.frame();
       if (raw_frame->is_java_script()) {
         JSFunction* function =
             JSFunction::cast(JavaScriptFrame::cast(raw_frame)->function());
-        function->shared()->set_profiler_ticks(0);
+        if (function->IsOptimized()) continue;
+        SharedFunctionInfo* shared = function->shared();
+        if (FLAG_watch_ic_patching) {
+          shared->set_profiler_ticks(0);
+        }
+        if (increment_ics_with_typeinfo) {
+          Code* code = shared->code();
+          if (address > code->instruction_start() &&

[Vyacheslav Egorov (Chromium), 2012/02/15 12:07:39]

I think Code has Contains method.

[Jakob Kummerow, 2012/02/17 16:07:52]

Thanks for the suggestion; but this is obsolete anyway due to your other
suggestions :-)

+              address < code->instruction_end()) {
+            shared->set_ic_typeinfo_count(shared->ic_typeinfo_count() + 1);

[Vyacheslav Egorov (Chromium), 2012/02/15 12:07:39]

Please add a small comment that this what this code actually does: it tries to
find s.f.i that owns code that contains given IC.

[Jakob Kummerow, 2012/02/17 16:07:52]

This is obsolete too.

+            increment_ics_with_typeinfo = false;  // Done.
+          }
+        }
       }
       it.Advance();
     }
   }
 }
 
 
 void IC::Clear(Address address) {
   Code* target = GetTargetAtAddress(address);
 
@@ skipping 2199 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal