Patch CEntry stub to swallow exception if liveedit/restart frame needs it.

src/debug.h

 // 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 351 matching lines @@
   // Getters for the current exception break state.
   bool break_on_exception() { return break_on_exception_; }
   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_restarter_frame_function_pointer,
+    k_c_entry_frame_to_ignore_exception
   };
 
   // Support for setting the address to jump to when returning from break point.
   Address* after_break_target_address() {
     return reinterpret_cast<Address*>(&thread_local_.after_break_target_);
   }
   Address* restarter_frame_function_pointer_address() {
     Object*** address = &thread_local_.restarter_frame_function_pointer_;
     return reinterpret_cast<Address*>(address);
   }
 
+  void set_c_entry_frame_to_ignore_exception(Address fp) {
+    thread_local_.c_entry_frame_to_ignore_exception_ = fp;
+  }
+
+  Address* c_entry_frame_to_ignore_exception_address() {
+    return &thread_local_.c_entry_frame_to_ignore_exception_;
+  }
+
   // Support for saving/restoring registers when handling debug break calls.
   Object** register_address(int r) {
     return &registers_[r];
   }
 
   // Access to the debug break on return code.
   Code* debug_break_return() { return debug_break_return_; }
   Code** debug_break_return_address() {
     return &debug_break_return_;
   }
@@ skipping 215 matching lines @@
     // Top debugger entry.
     EnterDebugger* debugger_entry_;
 
     // Pending interrupts scheduled while debugging.
     int pending_interrupts_;
 
     // When restarter frame is on stack, stores the address
     // of the pointer to function being restarted. Otherwise (most of the time)
     // stores NULL. This pointer is used with 'step in' implementation.
     Object** restarter_frame_function_pointer_;
+
+    // Store fp of CEntry frame, that should swallow exception and return
+    // normally (because calling frame has already been patched).
+    Address c_entry_frame_to_ignore_exception_;
   };
 
   // Storage location for registers when handling debug break calls
   JSCallerSavedBuffer registers_;
   ThreadLocal thread_local_;
   void ThreadInit();
 
   // Code to call for handling debug break on return.
   Code* debug_break_return_;
 
@@ skipping 386 matching lines @@
   }
 
   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 CEntryFrameToIgnoreException() {
+    return Debug_Address(Debug::k_c_entry_frame_to_ignore_exception);
+  }
+
   Address address(Isolate* isolate) const {
     Debug* debug = isolate->debug();
     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_c_entry_frame_to_ignore_exception:
+        return reinterpret_cast<Address>(
+            debug->c_entry_frame_to_ignore_exception_address());
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 
  private:
   Debug::AddressId id_;
 };
 
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 #endif  // V8_DEBUG_H_