Allow to capture stack trace for uncaught exceptions

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 26 matching lines @@
 #include "string-stream.h"
 
 namespace v8 {
 namespace internal {
 
 ThreadLocalTop Top::thread_local_;
 Mutex* Top::break_access_ = OS::CreateMutex();
 
 NoAllocationStringAllocator* preallocated_message_space = NULL;
 
+bool capture_stack_trace_for_uncaught_exceptions = false;
+int stack_trace_for_uncaught_exceptions_frame_limit = 0;
+StackTrace::StackTraceOptions stack_trace_for_uncaught_exceptions_options =
+    StackTrace::kOverview;
+
 Address top_addresses[] = {
 #define C(name) reinterpret_cast<Address>(Top::name()),
     TOP_ADDRESS_LIST(C)
     TOP_ADDRESS_LIST_PROF(C)
 #undef C
     NULL
 };
 
 
 v8::TryCatch* ThreadLocalTop::TryCatchHandler() {
@@ skipping 301 matching lines @@
     incomplete_message->OutputToStdOut();
     return Factory::empty_symbol();
   } else {
     OS::Abort();
     // Unreachable
     return Factory::empty_symbol();
   }
 }
 
 
-Local<StackTrace> Top::CaptureCurrentStackTrace(
+Handle<JSArray> Top::CaptureCurrentStackTrace(
     int frame_limit, StackTrace::StackTraceOptions options) {
-  v8::HandleScope scope;
   // 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> function_key =  Factory::LookupAsciiSymbol("functionName");
   Handle<String> eval_key =  Factory::LookupAsciiSymbol("isEval");
   Handle<String> constructor_key =  Factory::LookupAsciiSymbol("isConstructor");
@@ skipping 55 matching lines @@
           Factory::true_value() : Factory::false_value();
       SetProperty(stackFrame, constructor_key, is_constructor, NONE);
     }
 
     FixedArray::cast(stack_trace->elements())->set(frames_seen, *stackFrame);
     frames_seen++;
     it.Advance();
   }
 
   stack_trace->set_length(Smi::FromInt(frames_seen));
-  return scope.Close(Utils::StackTraceToLocal(stack_trace));
+  return stack_trace;
 }
 
 
 void Top::PrintStack() {
   if (stack_trace_nesting_level == 0) {
     stack_trace_nesting_level++;
 
     StringAllocator* allocator;
     if (preallocated_message_space == NULL) {
       allocator = new HeapStringAllocator();
@@ skipping 217 matching lines @@
 
 Failure* Top::StackOverflow() {
   HandleScope scope;
   Handle<String> key = Factory::stack_overflow_symbol();
   Handle<JSObject> boilerplate =
       Handle<JSObject>::cast(GetProperty(Top::builtins(), key));
   Handle<Object> exception = Copy(boilerplate);
   // TODO(1240995): To avoid having to call JavaScript code to compute
   // the message for stack overflow exceptions which is very likely to
   // double fault with another stack overflow exception, we use a
-  // precomputed message. This is somewhat problematic in that it
-  // doesn't use ReportUncaughtException to determine the location
-  // from where the exception occurred. It should probably be
-  // reworked.
+  // precomputed message.
   DoThrow(*exception, NULL, kStackOverflowMessage);
   return Failure::Exception();
 }
 
 
 Failure* Top::TerminateExecution() {
   DoThrow(Heap::termination_exception(), NULL, NULL);
   return Failure::Exception();
 }
 
@@ skipping 73 matching lines @@
         !(Script::cast(script)->source()->IsUndefined())) {
       int pos = frame->code()->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);
     }
   }
 }
 
 
-void Top::ReportUncaughtException(Handle<Object> exception,
-                                  MessageLocation* location,
-                                  Handle<String> stack_trace) {
-  Handle<Object> message;
-  if (!Bootstrapper::IsActive()) {
-    // It's not safe to try to make message objects while the bootstrapper
-    // is active since the infrastructure may not have been properly
-    // initialized.
-    message =
-      MessageHandler::MakeMessageObject("uncaught_exception",
-                                        location,
-                                        HandleVector<Object>(&exception, 1),
-                                        stack_trace);
-  }
-  // Report the uncaught exception.
-  MessageHandler::ReportMessage(location, message);
-}
-
-
 bool Top::ShouldReturnException(bool* is_caught_externally,
                                 bool catchable_by_javascript) {
   // Find the top-most try-catch handler.
   StackHandler* handler =
       StackHandler::FromAddress(Top::handler(Top::GetCurrentThread()));
   while (handler != NULL && !handler->is_try_catch()) {
     handler = handler->next();
   }
 
   // Get the address of the external handler so we can compare the address to
@@ skipping 52 matching lines @@
       // 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.
       Handle<String> stack_trace;
       if (FLAG_trace_exception) stack_trace = StackTraceString();
+      Handle<JSArray> stack_trace_object;
+      if (report_exception && capture_stack_trace_for_uncaught_exceptions) {
+          stack_trace_object = Top::CaptureCurrentStackTrace(
+              stack_trace_for_uncaught_exceptions_frame_limit,
+              stack_trace_for_uncaught_exceptions_options);
+      }
       message_obj = MessageHandler::MakeMessageObject("uncaught_exception",
-          location, HandleVector<Object>(&exception_handle, 1), stack_trace);
+          location, HandleVector<Object>(&exception_handle, 1), stack_trace,
+          stack_trace_object);
     }
   }
 
   // Save the message for reporting if the the exception remains uncaught.
   thread_local_.has_pending_message_ = report_exception;
   thread_local_.pending_message_ = message;
   if (!message_obj.is_null()) {
     thread_local_.pending_message_obj_ = *message_obj;
     if (location != NULL) {
       thread_local_.pending_message_script_ = *location->script();
@@ skipping 106 matching lines @@
     }
   }
 
   // Reschedule the exception.
   thread_local_.scheduled_exception_ = pending_exception();
   clear_pending_exception();
   return true;
 }
 
 
+void Top::SetCaptureStackTraceForUncaughtExceptions(
+      bool capture,
+      int frame_limit,
+      StackTrace::StackTraceOptions options) {
+  capture_stack_trace_for_uncaught_exceptions = capture;
+  stack_trace_for_uncaught_exceptions_frame_limit = frame_limit;
+  stack_trace_for_uncaught_exceptions_options = options;
+}
+
+
 bool Top::is_out_of_memory() {
   if (has_pending_exception()) {
     Object* e = pending_exception();
     if (e->IsFailure() && Failure::cast(e)->IsOutOfMemoryException()) {
       return true;
     }
   }
   if (has_scheduled_exception()) {
     Object* e = scheduled_exception();
     if (e->IsFailure() && Failure::cast(e)->IsOutOfMemoryException()) {
@@ skipping 49 matching lines @@
   Top::break_access_->Lock();
 }
 
 
 ExecutionAccess::~ExecutionAccess() {
   Top::break_access_->Unlock();
 }
 
 
 } }  // namespace v8::internal