[Isolates] Merge 6700:7030 from bleeding_edge to isolates.

src/top.cc

 // 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 174 matching lines @@
   }
 }
 
 
 Handle<JSArray> Isolate::CaptureCurrentStackTrace(
     int frame_limit, StackTrace::StackTraceOptions options) {
   // Ensure no negative values.
   int limit = Max(frame_limit, 0);
   Handle<JSArray> stack_trace = factory()->NewJSArray(frame_limit);
 
-  Handle<String> column_key =  factory()->LookupAsciiSymbol("column");
-  Handle<String> line_key =  factory()->LookupAsciiSymbol("lineNumber");
-  Handle<String> script_key =  factory()->LookupAsciiSymbol("scriptName");
+  Handle<String> column_key = factory()->LookupAsciiSymbol("column");
+  Handle<String> line_key = factory()->LookupAsciiSymbol("lineNumber");
+  Handle<String> script_key = factory()->LookupAsciiSymbol("scriptName");
   Handle<String> name_or_source_url_key =
       factory()->LookupAsciiSymbol("nameOrSourceURL");
   Handle<String> script_name_or_source_url_key =
       factory()->LookupAsciiSymbol("scriptNameOrSourceURL");
-  Handle<String> function_key =  factory()->LookupAsciiSymbol("functionName");
-  Handle<String> eval_key =  factory()->LookupAsciiSymbol("isEval");
+  Handle<String> function_key = factory()->LookupAsciiSymbol("functionName");
+  Handle<String> eval_key = factory()->LookupAsciiSymbol("isEval");
   Handle<String> constructor_key =
       factory()->LookupAsciiSymbol("isConstructor");
 
   StackTraceFrameIterator it;
   int frames_seen = 0;
   while (!it.done() && (frames_seen < limit)) {
     JavaScriptFrame* frame = it.frame();
 
     List<FrameSummary> frames(3);  // Max 2 levels of inlining.
     frame->Summarize(&frames);
@@ skipping 13 matching lines @@
         if (options & StackTrace::kColumnOffset && relative_line_number >= 0) {
           Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
           int start = (relative_line_number == 0) ? 0 :
               Smi::cast(line_ends->get(relative_line_number - 1))->value() + 1;
           int column_offset = position - start;
           if (relative_line_number == 0) {
             // For the case where the code is on the same line as the script
             // tag.
             column_offset += script->column_offset()->value();
           }
-          SetProperty(stackFrame, column_key,
-                      Handle<Smi>(Smi::FromInt(column_offset + 1), this), NONE);
+          SetLocalPropertyNoThrow(stackFrame, column_key,
+                                  Handle<Smi>(Smi::FromInt(column_offset + 1)));
         }
-        SetProperty(stackFrame, line_key,
-                    Handle<Smi>(Smi::FromInt(line_number + 1), this), NONE);
+        SetLocalPropertyNoThrow(stackFrame, line_key,
+                                Handle<Smi>(Smi::FromInt(line_number + 1)));
       }
 
       if (options & StackTrace::kScriptName) {
         Handle<Object> script_name(script->name(), this);
-        SetProperty(stackFrame, script_key, script_name, NONE);
+        SetLocalPropertyNoThrow(stackFrame, script_key, script_name);
       }
 
       if (options & StackTrace::kScriptNameOrSourceURL) {
         Handle<Object> script_name(script->name(), this);
         Handle<JSValue> script_wrapper = GetScriptWrapper(script);
         Handle<Object> property = GetProperty(script_wrapper,
                                               name_or_source_url_key);
         ASSERT(property->IsJSFunction());
         Handle<JSFunction> method = Handle<JSFunction>::cast(property);
         bool caught_exception;
         Handle<Object> result = Execution::TryCall(method, script_wrapper, 0,
                                                    NULL, &caught_exception);
         if (caught_exception) {
           result = factory()->undefined_value();
         }
-        SetProperty(stackFrame, script_name_or_source_url_key, result, NONE);
+        SetLocalPropertyNoThrow(stackFrame, script_name_or_source_url_key,
+                                result);
       }
 
       if (options & StackTrace::kFunctionName) {
         Handle<Object> fun_name(fun->shared()->name(), this);
         if (fun_name->ToBoolean()->IsFalse()) {
           fun_name = Handle<Object>(fun->shared()->inferred_name(), this);
         }
-        SetProperty(stackFrame, function_key, fun_name, NONE);
+        SetLocalPropertyNoThrow(stackFrame, function_key, fun_name);
       }
 
       if (options & StackTrace::kIsEval) {
         int type = Smi::cast(script->compilation_type())->value();
         Handle<Object> is_eval = (type == Script::COMPILATION_TYPE_EVAL) ?
             factory()->true_value() : factory()->false_value();
-        SetProperty(stackFrame, eval_key, is_eval, NONE);
+        SetLocalPropertyNoThrow(stackFrame, eval_key, is_eval);
       }
 
       if (options & StackTrace::kIsConstructor) {
         Handle<Object> is_constructor = (frames[i].is_constructor()) ?
             factory()->true_value() : factory()->false_value();
-        SetProperty(stackFrame, constructor_key, is_constructor, NONE);
+        SetLocalPropertyNoThrow(stackFrame, constructor_key, is_constructor);
       }
 
       FixedArray::cast(stack_trace->elements())->set(frames_seen, *stackFrame);
       frames_seen++;
     }
     it.Advance();
   }
 
   stack_trace->set_length(Smi::FromInt(frames_seen));
   return stack_trace;
@@ skipping 244 matching lines @@
 }
 
 
 Failure* Isolate::Throw(Object* exception, MessageLocation* location) {
   DoThrow(exception, location, NULL);
   return Failure::Exception();
 }
 
 
 Failure* Isolate::ReThrow(MaybeObject* exception, MessageLocation* location) {
+  bool can_be_caught_externally = false;
+  ShouldReportException(&can_be_caught_externally,
+                        is_catchable_by_javascript(exception));
+  thread_local_top()->catcher_ = can_be_caught_externally ?
+      try_catch_handler() : NULL;
+
   // Set the exception being re-thrown.
   set_pending_exception(exception);
   return Failure::Exception();
 }
 
 
 Failure* Isolate::ThrowIllegalOperation() {
   return Throw(heap_.illegal_access_symbol());
 }
 
@@ skipping 55 matching lines @@
         !(Script::cast(script)->source()->IsUndefined())) {
       int pos = frame->LookupCode(this)->SourcePosition(frame->pc());
       // Compute the location from the function and the reloc info.
       Handle<Script> casted_script(Script::cast(script));
       *target = MessageLocation(casted_script, pos, pos + 1);
     }
   }
 }
 
 
-bool Isolate::ShouldReportException(bool* is_caught_externally,
+bool Isolate::ShouldReportException(bool* can_be_caught_externally,
                                     bool catchable_by_javascript) {
   // Find the top-most try-catch handler.
   StackHandler* handler =
       StackHandler::FromAddress(Isolate::handler(thread_local_top()));
   while (handler != NULL && !handler->is_try_catch()) {
     handler = handler->next();
   }
 
   // Get the address of the external handler so we can compare the address to
   // determine which one is closer to the top of the stack.
   Address external_handler_address =
       thread_local_top()->try_catch_handler_address();
 
   // The exception has been externally caught if and only if there is
   // an external handler which is on top of the top-most try-catch
   // handler.
-  *is_caught_externally = external_handler_address != NULL &&
+  *can_be_caught_externally = external_handler_address != NULL &&
       (handler == NULL || handler->address() > external_handler_address ||
        !catchable_by_javascript);
 
-  if (*is_caught_externally) {
+  if (*can_be_caught_externally) {
     // Only report the exception if the external handler is verbose.
-    return thread_local_top()->TryCatchHandler()->is_verbose_;
+    return try_catch_handler()->is_verbose_;
   } else {
     // Report the exception if it isn't caught by JavaScript code.
     return handler == NULL;
   }
 }
 
 
 void Isolate::DoThrow(MaybeObject* exception,
                       MessageLocation* location,
                       const char* message) {
   ASSERT(!has_pending_exception());
 
   HandleScope scope;
   Object* exception_object = Smi::FromInt(0);
   bool is_object = exception->ToObject(&exception_object);
   Handle<Object> exception_handle(exception_object);
 
   // Determine reporting and whether the exception is caught externally.
-  bool is_out_of_memory = exception == Failure::OutOfMemoryException();
-  bool is_termination_exception = exception == heap_.termination_exception();
-  bool catchable_by_javascript = !is_termination_exception && !is_out_of_memory;
+  bool catchable_by_javascript = is_catchable_by_javascript(exception);
   // Only real objects can be caught by JS.
   ASSERT(!catchable_by_javascript || is_object);
-  bool is_caught_externally = false;
+  bool can_be_caught_externally = false;
   bool should_report_exception =
-      ShouldReportException(&is_caught_externally, catchable_by_javascript);
+      ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
   bool report_exception = catchable_by_javascript && should_report_exception;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   // Notify debugger of exception.
   if (catchable_by_javascript) {
     debugger_->OnException(exception_handle, report_exception);
   }
 #endif
 
   // Generate the message.
   Handle<Object> message_obj;
   MessageLocation potential_computed_location;
   bool try_catch_needs_message =
-      is_caught_externally &&
-      thread_local_top()->TryCatchHandler()->capture_message_;
+      can_be_caught_externally &&
+      try_catch_handler()->capture_message_;
   if (report_exception || try_catch_needs_message) {
     if (location == NULL) {
       // If no location was specified we use a computed one instead
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
     if (!bootstrapper()->IsActive()) {
       // It's not safe to try to make message objects or collect stack
       // traces while the bootstrapper is active since the infrastructure
       // may not have been properly initialized.
@@ skipping 17 matching lines @@
   thread_local_top()->pending_message_ = message;
   if (!message_obj.is_null()) {
     thread_local_top()->pending_message_obj_ = *message_obj;
     if (location != NULL) {
       thread_local_top()->pending_message_script_ = *location->script();
       thread_local_top()->pending_message_start_pos_ = location->start_pos();
       thread_local_top()->pending_message_end_pos_ = location->end_pos();
     }
   }
 
-  if (is_caught_externally) {
-    thread_local_top()->catcher_ = thread_local_top()->TryCatchHandler();
-  }
+  // Do not forget to clean catcher_ if currently thrown exception cannot
+  // be caught.  If necessary, ReThrow will update the catcher.
+  thread_local_top()->catcher_ = can_be_caught_externally ?
+      try_catch_handler() : NULL;
 
   // NOTE: Notifying the debugger or generating the message
   // may have caused new exceptions. For now, we just ignore
   // that and set the pending exception to the original one.
   if (is_object) {
     set_pending_exception(*exception_handle);
   } else {
     // Failures are not on the heap so they neither need nor work with handles.
     ASSERT(exception_handle->IsFailure());
     set_pending_exception(exception);
   }
 }
 
 
+bool Isolate::IsExternallyCaught() {
+  ASSERT(has_pending_exception());
+
+  if ((thread_local_top()->catcher_ == NULL) ||
+      (try_catch_handler() != thread_local_top()->catcher_)) {
+    // When throwing the exception, we found no v8::TryCatch
+    // which should care about this exception.
+    return false;
+  }
+
+  if (!is_catchable_by_javascript(pending_exception())) {
+    return true;
+  }
+
+  // Get the address of the external handler so we can compare the address to
+  // determine which one is closer to the top of the stack.
+  Address external_handler_address =
+      thread_local_top()->try_catch_handler_address();
+  ASSERT(external_handler_address != NULL);
+
+  // The exception has been externally caught if and only if there is
+  // an external handler which is on top of the top-most try-finally
+  // handler.
+  // There should be no try-catch blocks as they would prohibit us from
+  // finding external catcher in the first place (see catcher_ check above).
+  //
+  // Note, that finally clause would rethrow an exception unless it's
+  // aborted by jumps in control flow like return, break, etc. and we'll
+  // have another chances to set proper v8::TryCatch.
+  StackHandler* handler =
+      StackHandler::FromAddress(Isolate::handler(thread_local_top()));
+  while (handler != NULL && handler->address() < external_handler_address) {
+    ASSERT(!handler->is_try_catch());
+    if (handler->is_try_finally()) return false;
+
+    handler = handler->next();
+  }
+
+  return true;
+}
+
+
 void Isolate::ReportPendingMessages() {
   ASSERT(has_pending_exception());
-  setup_external_caught();
   // If the pending exception is OutOfMemoryException set out_of_memory in
   // the global context.  Note: We have to mark the global context here
   // since the GenerateThrowOutOfMemory stub cannot make a RuntimeCall to
   // set it.
-  bool external_caught = thread_local_top()->external_caught_exception_;
-  HandleScope scope;
+  bool external_caught = IsExternallyCaught();
+  thread_local_top()->external_caught_exception_ = external_caught;
+  HandleScope scope(this);
   if (thread_local_top()->pending_exception_ ==
       Failure::OutOfMemoryException()) {
     context()->mark_out_of_memory();
   } else if (thread_local_top()->pending_exception_ ==
              heap_.termination_exception()) {
     if (external_caught) {
-      thread_local_top()->TryCatchHandler()->can_continue_ = false;
-      thread_local_top()->TryCatchHandler()->exception_ = heap_.null_value();
+      try_catch_handler()->can_continue_ = false;
+      try_catch_handler()->exception_ = heap_.null_value();
     }
   } else {
     // At this point all non-object (failure) exceptions have
     // been dealt with so this shouldn't fail.
     Object* pending_exception_object = pending_exception()->ToObjectUnchecked();
     Handle<Object> exception(pending_exception_object);
     thread_local_top()->external_caught_exception_ = false;
     if (external_caught) {
-      thread_local_top()->TryCatchHandler()->can_continue_ = true;
-      thread_local_top()->TryCatchHandler()->exception_ =
-        thread_local_top()->pending_exception_;
+      try_catch_handler()->can_continue_ = true;
+      try_catch_handler()->exception_ = thread_local_top()->pending_exception_;
       if (!thread_local_top()->pending_message_obj_->IsTheHole()) {
         try_catch_handler()->message_ =
             thread_local_top()->pending_message_obj_;
       }
     }
     if (thread_local_top()->has_pending_message_) {
       thread_local_top()->has_pending_message_ = false;
       if (thread_local_top()->pending_message_ != NULL) {
         MessageHandler::ReportMessage(thread_local_top()->pending_message_);
       } else if (!thread_local_top()->pending_message_obj_->IsTheHole()) {
@@ skipping 142 matching lines @@
   thread_local_top()->simulator_ = Simulator::current(this);
 #endif
 #endif
   if (RuntimeProfiler::IsEnabled() && current_vm_state() == JS) {
     RuntimeProfiler::IsolateEnteredJS(this);
   }
   return from + sizeof(ThreadLocalTop);
 }
 
 } }  // namespace v8::internal