Combine DEBUG_BREAK and DEBUG_PREPARE_STEP_IN into one IC stub kind DEBUG_STUB, encoding DEBUG_BREA…

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 34 matching lines @@
     case UNINITIALIZED: return '0';
     case PREMONOMORPHIC: return '.';
     case MONOMORPHIC: return '1';
     case MONOMORPHIC_PROTOTYPE_FAILURE: return '^';
     case POLYMORPHIC: return 'P';
     case MEGAMORPHIC: return IsGeneric() ? 'G' : 'N';
 
     // We never see the debugger states here, because the state is
     // computed from the original code - not the patched code. Let
     // these cases fall through to the unreachable code below.
-    case DEBUG_BREAK: break;
-    case DEBUG_PREPARE_STEP_IN: break;
+    case DEBUG_STUB: break;
   }
   UNREACHABLE();
   return 0;
 }
 
 void IC::TraceIC(const char* type,
                  Handle<Object> name,
                  State old_state,
                  Code* new_target) {
   if (FLAG_trace_ic) {
@@ skipping 273 matching lines @@
   // TODO(2029): When an optimized function is patched, it would
   // be nice to propagate the corresponding type information to its
   // unoptimized version for the benefit of later inlining.
 }
 
 
 void IC::Clear(Address address) {
   Code* target = GetTargetAtAddress(address);
 
   // Don't clear debug break inline cache as it will remove the break point.
-  if (target->ic_state() == DEBUG_BREAK) return;
+  if (target->ic_state() == DEBUG_STUB &&
+      target->extra_ic_state() == DEBUG_BREAK) {
+    return;
+  }
 
   switch (target->kind()) {
     case Code::LOAD_IC: return LoadIC::Clear(address, target);
     case Code::KEYED_LOAD_IC:
       return KeyedLoadIC::Clear(address, target);
     case Code::STORE_IC: return StoreIC::Clear(address, target);
     case Code::KEYED_STORE_IC:
       return KeyedStoreIC::Clear(address, target);
     case Code::CALL_IC: return CallIC::Clear(address, target);
     case Code::KEYED_CALL_IC:  return KeyedCallIC::Clear(address, target);
@@ skipping 402 matching lines @@
     case MEGAMORPHIC: {
       // Cache code holding map should be consistent with
       // GenerateMonomorphicCacheProbe. It is not the map which holds the stub.
       Handle<JSObject> cache_object = object->IsJSObject()
           ? Handle<JSObject>::cast(object)
           : Handle<JSObject>(JSObject::cast(object->GetPrototype()));
       // Update the stub cache.
       isolate()->stub_cache()->Set(*name, cache_object->map(), *code);
       break;
     }
-    case DEBUG_BREAK:
-    case DEBUG_PREPARE_STEP_IN:
+    case DEBUG_STUB:
       break;
     case POLYMORPHIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC(kind_ == Code::CALL_IC ? "CallIC" : "KeyedCallIC",
            name, state, target());
 }
 
@@ skipping 274 matching lines @@
         isolate()->stub_cache()->Set(*name, receiver->map(), *code);
 
         set_target(*megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Cache code holding map should be consistent with
       // GenerateMonomorphicCacheProbe.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
       break;
-    case DEBUG_BREAK:
-    case DEBUG_PREPARE_STEP_IN:
+    case DEBUG_STUB:
       break;
     case POLYMORPHIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("LoadIC", name, state, target());
 }
 
 
@@ skipping 251 matching lines @@
     case POLYMORPHIC:
       set_target(*code);
       break;
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target(*megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
-    case DEBUG_BREAK:
-    case DEBUG_PREPARE_STEP_IN:
+    case DEBUG_STUB:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedLoadIC", name, state, target());
 }
 
 
@@ skipping 254 matching lines @@
         isolate()->stub_cache()->Set(*name, receiver->map(), *code);
         set_target((strict_mode == kStrictMode)
                      ? megamorphic_stub_strict()
                      : megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
       // Update the stub cache.
       isolate()->stub_cache()->Set(*name, receiver->map(), *code);
       break;
-    case DEBUG_BREAK:
-    case DEBUG_PREPARE_STEP_IN:
+    case DEBUG_STUB:
       break;
     case POLYMORPHIC:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("StoreIC", name, state, target());
 }
 
 
@@ skipping 30 matching lines @@
           ASSERT(object->IsMap());
           AddOneReceiverMapIfMissing(result, Handle<Map>::cast(object));
         }
         break;
       }
       case MEGAMORPHIC:
         break;
       case UNINITIALIZED:
       case PREMONOMORPHIC:
       case MONOMORPHIC_PROTOTYPE_FAILURE:
-      case DEBUG_BREAK:
-      case DEBUG_PREPARE_STEP_IN:
+      case DEBUG_STUB:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
 Handle<Code> KeyedIC::ComputeStub(Handle<JSObject> receiver,
                                   StubKind stub_kind,
                                   StrictModeFlag strict_mode,
@@ skipping 425 matching lines @@
       break;
     case MONOMORPHIC:
       // Only move to megamorphic if the target changes.
       if (target() != *code) {
         set_target((strict_mode == kStrictMode)
                      ? *megamorphic_stub_strict()
                      : *megamorphic_stub());
       }
       break;
     case MEGAMORPHIC:
-    case DEBUG_BREAK:
-    case DEBUG_PREPARE_STEP_IN:
+    case DEBUG_STUB:
       break;
     case MONOMORPHIC_PROTOTYPE_FAILURE:
       UNREACHABLE();
       break;
   }
 
   TRACE_IC("KeyedStoreIC", name, state, target());
 }
 
 
@@ skipping 735 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal