Basic implementation of incremental marking.

src/debug.cc

 // 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 355 matching lines @@
   ASSERT(!IsDebugBreak());
 }
 
 
 void BreakLocationIterator::PrepareStepIn() {
   HandleScope scope;
 
   // Step in can only be prepared if currently positioned on an IC call,
   // construct call or CallFunction stub call.
   Address target = rinfo()->target_address();
   Handle<Code> code(Code::GetCodeFromTargetAddress(target));

[Erik Corry, 2011/02/22 12:27:19]

Perhaps rename this variable to something more meaningful, then you can replace
this->code() with just code() below.

[Vyacheslav Egorov (Chromium), 2011/02/23 14:31:46]

Done.

   if (code->is_call_stub() || code->is_keyed_call_stub()) {
     // Step in through IC call is handled by the runtime system. Therefore make
     // sure that the any current IC is cleared and the runtime system is
     // called. If the executing code has a debug break at the location change
     // the call in the original code as it is the code there that will be
     // executed in place of the debug break call.
     Handle<Code> stub = ComputeCallDebugPrepareStepIn(code->arguments_count(),
                                                       code->kind());
     if (IsDebugBreak()) {
-      original_rinfo()->set_target_address(stub->entry());
+      original_rinfo()->set_target_address(stub->entry(), this->code());
     } else {
-      rinfo()->set_target_address(stub->entry());
+      rinfo()->set_target_address(stub->entry(), this->code());
     }
   } else {
 #ifdef DEBUG
     // All the following stuff is needed only for assertion checks so the code
     // is wrapped in ifdef.
     Handle<Code> maybe_call_function_stub = code;
     if (IsDebugBreak()) {
       Address original_target = original_rinfo()->target_address();
       maybe_call_function_stub =
           Handle<Code>(Code::GetCodeFromTargetAddress(original_target));
@@ skipping 35 matching lines @@
     return IsDebugBreakAtSlot();
   } else {
     return Debug::IsDebugBreak(rinfo()->target_address());
   }
 }
 
 
 void BreakLocationIterator::SetDebugBreakAtIC() {
   // Patch the original code with the current address as the current address
   // might have changed by the inline caching since the code was copied.
-  original_rinfo()->set_target_address(rinfo()->target_address());
+  original_rinfo()->set_target_address(rinfo()->target_address(), this->code());
 
   RelocInfo::Mode mode = rmode();
   if (RelocInfo::IsCodeTarget(mode)) {
     Address target = rinfo()->target_address();
     Handle<Code> code(Code::GetCodeFromTargetAddress(target));
 
     // Patch the code to invoke the builtin debug break function matching the
     // calling convention used by the call site.
     Handle<Code> dbgbrk_code(Debug::FindDebugBreak(code, mode));
-    rinfo()->set_target_address(dbgbrk_code->entry());
+    rinfo()->set_target_address(dbgbrk_code->entry(), this->code());
 
     // For stubs that refer back to an inlined version clear the cached map for
     // the inlined case to always go through the IC. As long as the break point
     // is set the patching performed by the runtime system will take place in
     // the code copy and will therefore have no effect on the running code
     // keeping it from using the inlined code.
     if (code->is_keyed_load_stub()) {
       KeyedLoadIC::ClearInlinedVersion(pc());
     } else if (code->is_keyed_store_stub()) {
       KeyedStoreIC::ClearInlinedVersion(pc());
     } else if (code->is_load_stub()) {
       LoadIC::ClearInlinedVersion(pc());
     } else if (code->is_store_stub()) {
       StoreIC::ClearInlinedVersion(pc());
     }
   }
 }
 
 
 void BreakLocationIterator::ClearDebugBreakAtIC() {
   // Patch the code to the original invoke.
-  rinfo()->set_target_address(original_rinfo()->target_address());
+  rinfo()->set_target_address(original_rinfo()->target_address(), code());
 
   RelocInfo::Mode mode = rmode();
   if (RelocInfo::IsCodeTarget(mode)) {
     AssertNoAllocation nogc;
     Address target = original_rinfo()->target_address();
     Code* code = Code::GetCodeFromTargetAddress(target);
 
     // Restore the inlined version of keyed stores to get back to the
     // fast case.  We need to patch back the keyed store because no
     // patching happens when running normally.  For keyed loads, the
@@ skipping 2588 matching lines @@
     {
       Locker locker;
       Debugger::CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal