Fix for bug 6767 - Limit stack trace collection for stack overflow exceptions.

runtime/vm/exceptions.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/exceptions.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_stacktrace_at_throw, false,
             "Prints a stack trace everytime a throw occurs.");
 DEFINE_FLAG(bool, heap_profile_out_of_memory, false,
             "Writes a heap profile on unhandled out-of-memory exceptions.");
 DEFINE_FLAG(bool, verbose_stacktrace, false,
     "Stack traces will include methods marked invisible.");
 
 const char* Exceptions::kCastErrorDstName = "type cast";
 
 
+class StacktraceBuilder : public ValueObject {
+ public:
+  StacktraceBuilder() { }
+  virtual ~StacktraceBuilder() { }
+
+  virtual void AddFrame(const Function& func,
+                        const Code& code,
+                        const Smi& offset) = 0;
+};
+
+
+class RegularStacktraceBuilder : public StacktraceBuilder {
+ public:
+  RegularStacktraceBuilder(const GrowableObjectArray& func_list,
+                           const GrowableObjectArray& code_list,
+                           const GrowableObjectArray& pc_offset_list)
+      : func_list_(func_list),
+        code_list_(code_list),
+        pc_offset_list_(pc_offset_list) { }
+  ~RegularStacktraceBuilder() { }
+
+  const GrowableObjectArray& func_list() const { return func_list_; }
+  const GrowableObjectArray& code_list() const { return code_list_; }
+  const GrowableObjectArray& pc_offset_list() const { return pc_offset_list_; }
+
+  void AddFrame(const Function& func, const Code& code, const Smi& offset) {
+    func_list_.Add(func);
+    code_list_.Add(code);
+    pc_offset_list_.Add(offset);
+  }
+
+ private:
+  const GrowableObjectArray& func_list_;
+  const GrowableObjectArray& code_list_;
+  const GrowableObjectArray& pc_offset_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(RegularStacktraceBuilder);
+};
+
+
+class PreallocatedStacktraceBuilder : public StacktraceBuilder {
+ public:
+  explicit PreallocatedStacktraceBuilder(const Stacktrace& stacktrace)
+      : stacktrace_(stacktrace),
+        cur_index_(0) {
+    ASSERT(stacktrace_.raw() ==
+           Isolate::Current()->object_store()->preallocated_stack_trace());
+  }
+  ~PreallocatedStacktraceBuilder() { }
+
+  void AddFrame(const Function& func, const Code& code, const Smi& offset);
+
+ private:
+  static const int kNumTopframes = 3;
+
+  const Stacktrace& stacktrace_;
+  intptr_t cur_index_;
+
+  DISALLOW_COPY_AND_ASSIGN(PreallocatedStacktraceBuilder);
+};
+
+
+void PreallocatedStacktraceBuilder::AddFrame(const Function& func,
+                                             const Code& code,
+                                             const Smi& offset) {
+  if (cur_index_ >= Stacktrace::kPreallocatedStackdepth) {
+    // The number of frames is overflowing the preallocated stack trace object.
+    Function& frame_func = Function::Handle();
+    Code& frame_code = Code::Handle();
+    Smi& frame_offset = Smi::Handle();
+    intptr_t start = Stacktrace::kPreallocatedStackdepth - (kNumTopframes - 1);
+    intptr_t null_slot = start - 2;
+    // Add an empty slot to indicate the overflow so that the toString
+    // method can account for the overflow.
+    if (stacktrace_.FunctionAtFrame(null_slot) != Function::null()) {
+      stacktrace_.SetFunctionAtFrame(null_slot, frame_func);
+      stacktrace_.SetCodeAtFrame(null_slot, frame_code);
+    }
+    // Move frames one slot down so that we can accomadate the new frame.
+    for (intptr_t i = start; i < Stacktrace::kPreallocatedStackdepth; i++) {
+      intptr_t prev = (i - 1);
+      frame_func = stacktrace_.FunctionAtFrame(i);
+      frame_code = stacktrace_.CodeAtFrame(i);
+      frame_offset = stacktrace_.PcOffsetAtFrame(i);
+      stacktrace_.SetFunctionAtFrame(prev, frame_func);
+      stacktrace_.SetCodeAtFrame(prev, frame_code);
+      stacktrace_.SetPcOffsetAtFrame(prev, frame_offset);
+    }
+    cur_index_ = (Stacktrace::kPreallocatedStackdepth - 1);
+  }
+  stacktrace_.SetFunctionAtFrame(cur_index_, func);
+  stacktrace_.SetCodeAtFrame(cur_index_, code);
+  stacktrace_.SetPcOffsetAtFrame(cur_index_, offset);
+  cur_index_ += 1;
+}
+
+
 static bool ShouldShowFunction(const Function& function) {
   if (FLAG_verbose_stacktrace) {
     return true;
   }
   return function.is_visible();
 }
 
 
 // Iterate through the stack frames and try to find a frame with an
 // exception handler. Once found, set the pc, sp and fp so that execution
 // can continue in that frame.
 static bool FindExceptionHandler(uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
-                                 const GrowableObjectArray& func_list,
-                                 const GrowableObjectArray& code_list,
-                                 const GrowableObjectArray& pc_offset_list) {
+                                 StacktraceBuilder* builder) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);  // We expect to find a dart invocation frame.
   Function& func = Function::Handle();
   Code& code = Code::Handle();
   Smi& offset = Smi::Handle();
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
       code = frame->LookupDartCode();
       if (code.is_optimized()) {
         // For optimized frames, extract all the inlined functions if any
         // into the stack trace.
         for (InlinedFunctionsIterator it(frame); !it.Done(); it.Advance()) {
           func = it.function();
           code = it.code();
           uword pc = it.pc();
           ASSERT(pc != 0);
           ASSERT(code.EntryPoint() <= pc);
           ASSERT(pc < (code.EntryPoint() + code.Size()));
           if (ShouldShowFunction(func)) {
             offset = Smi::New(pc - code.EntryPoint());
-            func_list.Add(func);
-            code_list.Add(code);
-            pc_offset_list.Add(offset);
+            builder->AddFrame(func, code, offset);
           }
         }
       } else {
         offset = Smi::New(frame->pc() - code.EntryPoint());
         func = code.function();
         if (ShouldShowFunction(func)) {
-          func_list.Add(func);
-          code_list.Add(code);
-          pc_offset_list.Add(offset);
+          builder->AddFrame(func, code, offset);
         }
       }
       if (frame->FindExceptionHandler(handler_pc)) {
         *handler_sp = frame->sp();
         *handler_fp = frame->fp();
         return true;
       }
     }
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
@@ skipping 75 matching lines @@
   typedef void (*ErrorHandler)(uword, uword, uword, RawError*);
   ErrorHandler func = reinterpret_cast<ErrorHandler>(
       StubCode::JumpToErrorHandlerEntryPoint());
   func(program_counter, stack_pointer, frame_pointer, raw_error);
   UNREACHABLE();
 }
 
 
 static void ThrowExceptionHelper(const Instance& incoming_exception,
                                  const Instance& existing_stacktrace) {
-  Instance& exception = Instance::Handle(incoming_exception.raw());
+  bool use_preallocated_stacktrace = false;
+  Isolate* isolate = Isolate::Current();
+  Instance& exception = Instance::Handle(isolate, incoming_exception.raw());
   if (exception.IsNull()) {
     exception ^= Exceptions::Create(Exceptions::kNullThrown,
                                     Object::empty_array());
+  } else if (exception.raw() == isolate->object_store()->out_of_memory() ||
+             exception.raw() == isolate->object_store()->stack_overflow()) {
+    use_preallocated_stacktrace = true;
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
-  const GrowableObjectArray& func_list =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  const GrowableObjectArray& code_list =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  const GrowableObjectArray& pc_offset_list =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  bool handler_exists = FindExceptionHandler(&handler_pc,
-                                             &handler_sp,
-                                             &handler_fp,
-                                             func_list,
-                                             code_list,
-                                             pc_offset_list);
+  Stacktrace& stacktrace = Stacktrace::Handle(isolate);
+  bool handler_exists = false;
+  if (use_preallocated_stacktrace) {
+    stacktrace ^= isolate->object_store()->preallocated_stack_trace();
+    PreallocatedStacktraceBuilder frame_builder(stacktrace);
+    handler_exists = FindExceptionHandler(&handler_pc,
+                                          &handler_sp,
+                                          &handler_fp,
+                                          &frame_builder);
+  } else {
+    RegularStacktraceBuilder frame_builder(
+        GrowableObjectArray::Handle(isolate, GrowableObjectArray::New()),
+        GrowableObjectArray::Handle(isolate, GrowableObjectArray::New()),
+        GrowableObjectArray::Handle(isolate, GrowableObjectArray::New()));
+    handler_exists = FindExceptionHandler(&handler_pc,
+                                          &handler_sp,
+                                          &handler_fp,
+                                          &frame_builder);
+    // TODO(5411263): At some point we can optimize by figuring out if a
+    // stack trace is needed based on whether the catch code specifies a
+    // stack trace object or there is a rethrow in the catch clause.
+    if (frame_builder.pc_offset_list().Length() != 0) {
+      // Create arrays for function, code and pc_offset triplet for each frame.
+      const Array& func_array =
+          Array::Handle(isolate, Array::MakeArray(frame_builder.func_list()));
+      const Array& code_array =
+          Array::Handle(isolate, Array::MakeArray(frame_builder.code_list()));
+      const Array& pc_offset_array =
+          Array::Handle(isolate,
+                        Array::MakeArray(frame_builder.pc_offset_list()));
+      if (existing_stacktrace.IsNull()) {
+        stacktrace = Stacktrace::New(func_array, code_array, pc_offset_array);
+      } else {
+        stacktrace ^= existing_stacktrace.raw();
+        stacktrace.Append(func_array, code_array, pc_offset_array);
+      }
+    } else {
+      stacktrace ^= existing_stacktrace.raw();
+    }
+  }
   // We expect to find a handler_pc, if the exception is unhandled
   // then we expect to at least have the dart entry frame on the
   // stack as Exceptions::Throw should happen only after a dart
   // invocation has been done.
   ASSERT(handler_pc != 0);
 
-  // TODO(5411263): At some point we can optimize by figuring out if a
-  // stack trace is needed based on whether the catch code specifies a
-  // stack trace object or there is a rethrow in the catch clause.
-  Stacktrace& stacktrace = Stacktrace::Handle();
-  if (pc_offset_list.Length() != 0) {
-    if (existing_stacktrace.IsNull()) {
-      stacktrace = Stacktrace::New(func_list, code_list, pc_offset_list);
-    } else {
-      stacktrace ^= existing_stacktrace.raw();
-      stacktrace.Append(func_list, code_list, pc_offset_list);
-    }
-  } else {
-    stacktrace ^= existing_stacktrace.raw();
-  }
   if (FLAG_print_stacktrace_at_throw) {
     OS::Print("Exception '%s' thrown:\n", exception.ToCString());
     OS::Print("%s\n", stacktrace.ToCString());
   }
   if (handler_exists) {
     // Found a dart handler for the exception, jump to it.
     JumpToExceptionHandler(handler_pc,
                            handler_sp,
                            handler_fp,
                            exception,
                            stacktrace);
   } else {
     if (FLAG_heap_profile_out_of_memory) {
-      Isolate* isolate = Isolate::Current();
       if (exception.raw() == isolate->object_store()->out_of_memory()) {
         isolate->heap()->ProfileToFile("out-of-memory");
       }
     }
     // No dart exception handler found in this invocation sequence,
     // so we create an unhandled exception object and return to the
     // invocation stub so that it returns this unhandled exception
     // object. The C++ code which invoked this dart sequence can check
     // and do the appropriate thing (rethrow the exception to the
     // dart invocation sequence above it, print diagnostics and terminate
@@ skipping 242 matching lines @@
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library,
                                            *class_name,
                                            *constructor_name,
                                            arguments);
 }
 
 }  // namespace dart