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

src/liveedit.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 1681 matching lines @@
   return change;
 }
 
 
 // Removes specified range of frames from stack. There may be 1 or more
 // frames in range. Anyway the bottom frame is restarted rather than dropped,
 // and therefore has to be a JavaScript frame.
 // Returns error message or NULL.
 static const char* DropFrames(Vector<StackFrame*> frames,
                               int top_frame_index,
-                              int bottom_js_frame_index,
+                              const int bottom_js_frame_index,
                               Debug::FrameDropMode* mode,
                               Object*** restarter_frame_function_pointer) {
   if (!Debug::kFrameDropperSupported) {
     return "Stack manipulations are not supported in this architecture.";
   }
 
   StackFrame* pre_top_frame = frames[top_frame_index - 1];
   StackFrame* top_frame = frames[top_frame_index];
   StackFrame* bottom_js_frame = frames[bottom_js_frame_index];
 
@@ skipping 10 matching lines @@
     frame_has_padding = Debug::FramePaddingLayout::kIsSupported;
   } else if (pre_top_frame_code ==
              isolate->debug()->debug_break_slot()) {
     // OK, we can drop debug break slot.
     *mode = Debug::FRAME_DROPPED_IN_DEBUG_SLOT_CALL;
     frame_has_padding = Debug::FramePaddingLayout::kIsSupported;
   } else if (pre_top_frame_code ==
       isolate->builtins()->builtin(
           Builtins::kFrameDropper_LiveEdit)) {
     // OK, we can drop our own code.
-    pre_top_frame = frames[top_frame_index - 2];
-    top_frame = frames[top_frame_index - 1];
+    top_frame_index--;
     *mode = Debug::CURRENTLY_SET_MODE;
     frame_has_padding = false;
   } else if (pre_top_frame_code ==
       isolate->builtins()->builtin(Builtins::kReturn_DebugBreak)) {
     *mode = Debug::FRAME_DROPPED_IN_RETURN_CALL;
     frame_has_padding = Debug::FramePaddingLayout::kIsSupported;
-  } else if (pre_top_frame_code->kind() == Code::STUB &&
-      pre_top_frame_code->major_key() == CodeStub::CEntry) {
-    // Entry from our unit tests on 'debugger' statement.
+  } else if (pre_top_frame->type() == StackFrame::EXIT) {
+    // Exit to C++ code. Could be 'debugger' statement or some regular code
+    // that cause exception throwing (including 'throw' statement).
     // It's fine, we support this case.
     *mode = Debug::FRAME_DROPPED_IN_DIRECT_CALL;
     // We don't have a padding from 'debugger' statement call.
     // Here the stub is CEntry, it's not debug-only and can't be padded.
     // If anyone would complain, a proxy padded stub could be added.
     frame_has_padding = false;
+  } else if (frames[top_frame_index - 2]->type() == StackFrame::EXIT) {
+    top_frame_index--;
+    // Same as above case.
+    *mode = Debug::FRAME_DROPPED_IN_DIRECT_CALL;
+    frame_has_padding = false;
   } else if (pre_top_frame->type() == StackFrame::ARGUMENTS_ADAPTOR) {
     // This must be adaptor that remain from the frame dropping that
     // is still on stack. A frame dropper frame must be above it.
     ASSERT(frames[top_frame_index - 2]->LookupCode() ==
         isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit));
-    pre_top_frame = frames[top_frame_index - 3];
-    top_frame = frames[top_frame_index - 2];
+    top_frame_index -= 2;
     *mode = Debug::CURRENTLY_SET_MODE;
     frame_has_padding = false;
   } else {
     return "Unknown structure of stack above changing function";
   }
 
+  pre_top_frame = frames[top_frame_index - 1];
+  top_frame = frames[top_frame_index];
+
   Address unused_stack_top = top_frame->sp();
   Address unused_stack_bottom = bottom_js_frame->fp()
       - Debug::kFrameDropperFrameSize * kPointerSize  // Size of the new frame.
       + kPointerSize;  // Bigger address end is exclusive.
 
   Address* top_frame_pc_address = top_frame->pc_address();
 
   // top_frame may be damaged below this point. Do not used it.
   ASSERT(!(top_frame = NULL));
 
+  bool use_padding = false;
   if (unused_stack_top > unused_stack_bottom) {
     if (frame_has_padding) {
+      use_padding = true;
+    } else {
+      return "Not enough space for frame dropper frame";
+    }
+  }
+
+  // Committing now. After this point we should return only NULL value.
+
+  if (use_padding) {
+    // Extra parenthses are temporary to retain indentation to keep diff clear.
+    // TODO(prybin): drop parenthses in a separate change.
+    {
       int shortage_bytes =
           static_cast<int>(unused_stack_top - unused_stack_bottom);
 
       Address padding_start = pre_top_frame->fp() -
           Debug::FramePaddingLayout::kFrameBaseSize * kPointerSize;
 
       Address padding_pointer = padding_start;
       Smi* padding_object =
           Smi::FromInt(Debug::FramePaddingLayout::kPaddingValue);
       while (Memory::Object_at(padding_pointer) == padding_object) {
@@ skipping 13 matching lines @@
       OS::MemMove(padding_start + kPointerSize - shortage_bytes,
                   padding_start + kPointerSize,
                   Debug::FramePaddingLayout::kFrameBaseSize * kPointerSize);
 
       pre_top_frame->UpdateFp(pre_top_frame->fp() - shortage_bytes);
       pre_pre_frame->SetCallerFp(pre_top_frame->fp());
       unused_stack_top -= shortage_bytes;
 
       STATIC_ASSERT(sizeof(Address) == kPointerSize);
       top_frame_pc_address -= shortage_bytes / kPointerSize;
-    } else {
-      return "Not enough space for frame dropper frame";
     }
   }
 
-  // Committing now. After this point we should return only NULL value.
+
+  if (pre_top_frame->type() == StackFrame::EXIT) {
+    isolate->debug()->set_c_entry_frame_to_ignore_exception(
+        pre_top_frame->fp());
+  }
 
   FixTryCatchHandler(pre_top_frame, bottom_js_frame);
   // Make sure FixTryCatchHandler is idempotent.
   ASSERT(!FixTryCatchHandler(pre_top_frame, bottom_js_frame));
 
   Handle<Code> code = isolate->builtins()->FrameDropper_LiveEdit();
   *top_frame_pc_address = code->entry();
   pre_top_frame->SetCallerFp(bottom_js_frame->fp());
 
   *restarter_frame_function_pointer =
@@ skipping 330 matching lines @@
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return false;
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 
 } }  // namespace v8::internal