Remove materialized objects on stack unwind.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 1007 matching lines @@
 
 Object* Isolate::ReThrow(Object* exception) {
   DCHECK(!has_pending_exception());
 
   // Set the exception being re-thrown.
   set_pending_exception(exception);
   return heap()->exception();
 }
 
 
-Object* Isolate::FindHandler() {
+Object* Isolate::UnwindAndFindHandler() {
   Object* exception = pending_exception();
 
   Code* code = nullptr;
   Context* context = nullptr;
   intptr_t offset = 0;
   Address handler_sp = nullptr;
   Address handler_fp = nullptr;
 
   // Special handling of termination exceptions, uncatchable by JavaScript code,
   // we unwind the handlers until the top ENTRY handler is found.
@@ skipping 16 matching lines @@
       handler_sp = handler->address() + StackHandlerConstants::kSize;
       offset = Smi::cast(code->handler_table()->get(0))->value();
       break;
     }
 
     // For optimized frames we perform a lookup in the handler table.
     if (frame->is_optimized() && catchable_by_js) {
       OptimizedFrame* js_frame = static_cast<OptimizedFrame*>(frame);
       int stack_slots = 0;  // Will contain stack slot count of frame.
       offset = js_frame->LookupExceptionHandlerInTable(&stack_slots);
-      if (offset < 0) continue;
+      if (offset >= 0) {
+        // Compute the stack pointer from the frame pointer. This ensures that
+        // argument slots on the stack are dropped as returning would.
+        Address return_sp = frame->fp() -
+                            StandardFrameConstants::kFixedFrameSizeFromFp -
+                            stack_slots * kPointerSize;
 
-      // Compute the stack pointer from the frame pointer. This ensures that
-      // argument slots on the stack are dropped as returning would.
-      Address return_sp = frame->fp() -
-                          StandardFrameConstants::kFixedFrameSizeFromFp -
-                          stack_slots * kPointerSize;
-
-      // Gather information from the frame.
-      code = frame->LookupCode();
-      handler_sp = return_sp;
-      handler_fp = frame->fp();
-      break;
+        // Gather information from the frame.
+        code = frame->LookupCode();
+        handler_sp = return_sp;
+        handler_fp = frame->fp();
+        break;
+      }
     }
 
     // For JavaScript frames we perform a range lookup in the handler table.
     if (frame->is_java_script() && catchable_by_js) {
       JavaScriptFrame* js_frame = static_cast<JavaScriptFrame*>(frame);
       int stack_slots = 0;  // Will contain operand stack depth of handler.
       offset = js_frame->LookupExceptionHandlerInTable(&stack_slots);
-      if (offset < 0) continue;
+      if (offset >= 0) {
+        // Compute the stack pointer from the frame pointer. This ensures that
+        // operand stack slots are dropped for nested statements. Also restore
+        // correct context for the handler which is pushed within the try-block.
+        Address return_sp = frame->fp() -
+                            StandardFrameConstants::kFixedFrameSizeFromFp -
+                            stack_slots * kPointerSize;
+        STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
+        context = Context::cast(Memory::Object_at(return_sp - kPointerSize));
 
-      // Compute the stack pointer from the frame pointer. This ensures that
-      // operand stack slots are dropped for nested statements. Also restore
-      // correct context for the handler which is pushed within the try-block.
-      Address return_sp = frame->fp() -
-                          StandardFrameConstants::kFixedFrameSizeFromFp -
-                          stack_slots * kPointerSize;
-      STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
-      context = Context::cast(Memory::Object_at(return_sp - kPointerSize));
+        // Gather information from the frame.
+        code = frame->LookupCode();
+        handler_sp = return_sp;
+        handler_fp = frame->fp();
+        break;
+      }
+    }
 
-      // Gather information from the frame.
-      code = frame->LookupCode();
-      handler_sp = return_sp;
-      handler_fp = frame->fp();
-      break;
-    }
+    RemoveMaterializedObjectsOnUnwind(frame);
   }
 
   // Handler must exist.
   CHECK(code != nullptr);
 
   // Store information to be consumed by the CEntryStub.
   thread_local_top()->pending_handler_context_ = context;
   thread_local_top()->pending_handler_code_ = code;
   thread_local_top()->pending_handler_offset_ = offset;
   thread_local_top()->pending_handler_fp_ = handler_fp;
@@ skipping 35 matching lines @@
         return CAUGHT_BY_EXTERNAL;
       }
     }
   }
 
   // Handler not found.
   return NOT_CAUGHT;
 }
 
 
+void Isolate::RemoveMaterializedObjectsOnUnwind(StackFrame* frame) {
+  if (frame->is_optimized()) {
+    bool removed = materialized_object_store_->Remove(frame->fp());
+    USE(removed);
+    // If there were any materialized objects, the code should be
+    // marked for deopt.
+    DCHECK(!removed || frame->LookupCode()->marked_for_deoptimization());
+  }
+}
+
+
 Object* Isolate::ThrowIllegalOperation() {
   if (FLAG_stack_trace_on_illegal) PrintStack(stdout);
   return Throw(heap()->illegal_access_string());
 }
 
 
 void Isolate::ScheduleThrow(Object* exception) {
   // When scheduling a throw we first throw the exception to get the
   // error reporting if it is uncaught before rescheduling it.
   Throw(exception);
@@ skipping 1589 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal