Cleanup the way the debugger stores live registers when entering at a break...

src/debug.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 314 matching lines @@
   // Getters for the current exception break state.
   static bool break_on_exception() { return break_on_exception_; }
   static bool break_on_uncaught_exception() {
     return break_on_uncaught_exception_;
   }
 
   enum AddressId {
     k_after_break_target_address,
     k_debug_break_return_address,
     k_debug_break_slot_address,
-    k_restarter_frame_function_pointer,
-    k_register_address
+    k_restarter_frame_function_pointer
   };
 
   // Support for setting the address to jump to when returning from break point.
   static Address* after_break_target_address() {
     return reinterpret_cast<Address*>(&thread_local_.after_break_target_);
   }
   static Address* restarter_frame_function_pointer_address() {
     Object*** address = &thread_local_.restarter_frame_function_pointer_;
     return reinterpret_cast<Address*>(address);
   }
@@ skipping 599 matching lines @@
   // The previous state of the disable break used to restore the value when this
   // object is destructed.
   bool prev_disable_break_;
 };
 
 
 // Debug_Address encapsulates the Address pointers used in generating debug
 // code.
 class Debug_Address {
  public:
-  Debug_Address(Debug::AddressId id, int reg = 0)
-    : id_(id), reg_(reg) {
-    ASSERT(reg == 0 || id == Debug::k_register_address);
-  }
+  Debug_Address(Debug::AddressId id) : id_(id) { }
 
   static Debug_Address AfterBreakTarget() {
     return Debug_Address(Debug::k_after_break_target_address);
   }
 
   static Debug_Address DebugBreakReturn() {
     return Debug_Address(Debug::k_debug_break_return_address);
   }
 
   static Debug_Address RestarterFrameFunctionPointer() {
     return Debug_Address(Debug::k_restarter_frame_function_pointer);
   }
 
-  static Debug_Address Register(int reg) {
-    return Debug_Address(Debug::k_register_address, reg);
-  }
-
   Address address() const {
     switch (id_) {
       case Debug::k_after_break_target_address:
         return reinterpret_cast<Address>(Debug::after_break_target_address());
       case Debug::k_debug_break_return_address:
         return reinterpret_cast<Address>(Debug::debug_break_return_address());
       case Debug::k_debug_break_slot_address:
         return reinterpret_cast<Address>(Debug::debug_break_slot_address());
       case Debug::k_restarter_frame_function_pointer:
         return reinterpret_cast<Address>(
             Debug::restarter_frame_function_pointer_address());
-      case Debug::k_register_address:
-        return reinterpret_cast<Address>(Debug::register_address(reg_));
       default:
         UNREACHABLE();
         return NULL;
     }
   }
  private:
   Debug::AddressId id_;
-  int reg_;
 };
 
 // The optional thread that Debug Agent may use to temporary call V8 to process
 // pending debug requests if debuggee is not running V8 at the moment.
 // Techincally it does not call V8 itself, rather it asks embedding program
 // to do this via v8::Debug::HostDispatchHandler
 class MessageDispatchHelperThread: public Thread {
  public:
   MessageDispatchHelperThread();
   ~MessageDispatchHelperThread();
 
   void Schedule();
 
  private:
   void Run();
 
   Semaphore* const sem_;
   Mutex* const mutex_;
   bool already_signalled_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 #endif  // V8_DEBUG_H_