Support compaction for code space pages.

src/debug.cc

 // Copyright 2011 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 392 matching lines @@
   Handle<Code> target_code(Code::GetCodeFromTargetAddress(target));
   if (target_code->is_call_stub() || target_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(
         target_code->arguments_count(), target_code->kind());
     if (IsDebugBreak()) {
-      original_rinfo()->set_target_address(stub->entry(), code());
+      original_rinfo()->set_target_address(stub->entry());
     } else {
-      rinfo()->set_target_address(stub->entry(), code());
+      rinfo()->set_target_address(stub->entry());
     }
   } 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 = target_code;
     if (IsDebugBreak()) {
       Address original_target = original_rinfo()->target_address();
       maybe_call_function_stub =
           Handle<Code>(Code::GetCodeFromTargetAddress(original_target));
@@ skipping 36 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(), code());
+  original_rinfo()->set_target_address(rinfo()->target_address());
 
   RelocInfo::Mode mode = rmode();
   if (RelocInfo::IsCodeTarget(mode)) {
     Address target = rinfo()->target_address();
     Handle<Code> target_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(target_code, mode));
-    rinfo()->set_target_address(dbgbrk_code->entry(), code());
+    rinfo()->set_target_address(dbgbrk_code->entry());
   }
 }
 
 
 void BreakLocationIterator::ClearDebugBreakAtIC() {
   // Patch the code to the original invoke.
-  rinfo()->set_target_address(original_rinfo()->target_address(), code());
+  rinfo()->set_target_address(original_rinfo()->target_address());
 }
 
 
 bool BreakLocationIterator::IsDebuggerStatement() {
   return RelocInfo::DEBUG_BREAK == rmode();
 }
 
 
 bool BreakLocationIterator::IsDebugBreakSlot() {
   return RelocInfo::DEBUG_BREAK_SLOT == rmode();
@@ skipping 2630 matching lines @@
     {
       Locker locker;
       Isolate::Current()->debugger()->CallMessageDispatchHandler();
     }
   }
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal