Fix for issue 11680

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"
@@ skipping 28 matching lines @@
 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;
+                        const Smi& offset,
+                        bool is_catch_frame) = 0;
+
+  virtual bool full_stacktrace() const = 0;
 };
 
 
 class RegularStacktraceBuilder : public StacktraceBuilder {
  public:
-  RegularStacktraceBuilder()
+  explicit RegularStacktraceBuilder(bool full_stacktrace)
       : func_list_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
         code_list_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
         pc_offset_list_(
-            GrowableObjectArray::Handle(GrowableObjectArray::New())) { }
+            GrowableObjectArray::Handle(GrowableObjectArray::New())),
+        catch_func_list_(
+            full_stacktrace ?
+            GrowableObjectArray::Handle(GrowableObjectArray::New()) :
+            GrowableObjectArray::Handle()),
+        catch_code_list_(
+            full_stacktrace ?
+            GrowableObjectArray::Handle(GrowableObjectArray::New()) :
+            GrowableObjectArray::Handle()),
+        catch_pc_offset_list_(
+            full_stacktrace ?
+            GrowableObjectArray::Handle(GrowableObjectArray::New()) :
+            GrowableObjectArray::Handle()),
+        full_stacktrace_(full_stacktrace) { }
   ~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_; }
+  const GrowableObjectArray& catch_func_list() const {
+    return catch_func_list_;
+  }
+  const GrowableObjectArray& catch_code_list() const {
+    return catch_code_list_;
+  }
+  const GrowableObjectArray& catch_pc_offset_list() const {
+    return catch_pc_offset_list_;
+  }
+  virtual bool full_stacktrace() const { return full_stacktrace_; }
 
   virtual void AddFrame(const Function& func,
                         const Code& code,
-                        const Smi& offset) {
-    func_list_.Add(func);
-    code_list_.Add(code);
-    pc_offset_list_.Add(offset);
+                        const Smi& offset,
+                        bool is_catch_frame) {
+    if (is_catch_frame) {
+      catch_func_list_.Add(func);
+      catch_code_list_.Add(code);
+      catch_pc_offset_list_.Add(offset);
+    } else {
+      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_;
+  const GrowableObjectArray& catch_func_list_;
+  const GrowableObjectArray& catch_code_list_;
+  const GrowableObjectArray& catch_pc_offset_list_;
+  bool full_stacktrace_;
 
   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() { }
 
   virtual void AddFrame(const Function& func,
                         const Code& code,
-                        const Smi& offset);
+                        const Smi& offset,
+                        bool is_catch_frame);
+
+  virtual bool full_stacktrace() const { return false; }
 
  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) {
+                                             const Smi& offset,
+                                             bool is_catch_frame) {
   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()) {
@@ skipping 33 matching lines @@
 static bool FindExceptionHandler(uword* handler_pc,
                                  uword* handler_sp,
                                  uword* handler_fp,
                                  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();
+  bool handler_found = false;
   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());
-            builder->AddFrame(func, code, offset);
+            builder->AddFrame(func, code, offset, handler_found);
           }
         }
       } else {
         offset = Smi::New(frame->pc() - code.EntryPoint());
         func = code.function();
         if (ShouldShowFunction(func)) {
-          builder->AddFrame(func, code, offset);
+          builder->AddFrame(func, code, offset, handler_found);
         }
       }
-      if (frame->FindExceptionHandler(handler_pc)) {
+      if (!handler_found && frame->FindExceptionHandler(handler_pc)) {
         *handler_sp = frame->sp();
         *handler_fp = frame->fp();
-        return true;
+        handler_found = true;
+        if (!builder->full_stacktrace()) {
+          return handler_found;
+        }
       }
     }
     frame = frames.NextFrame();
     ASSERT(frame != NULL);
   }
   ASSERT(frame->IsEntryFrame());
-  *handler_pc = frame->pc();
-  *handler_sp = frame->sp();
-  *handler_fp = frame->fp();
-  return false;
+  if (!handler_found) {
+    *handler_pc = frame->pc();
+    *handler_sp = frame->sp();
+    *handler_fp = frame->fp();
+  }
+  return handler_found;
 }
 
 
 static void FindErrorHandler(uword* handler_pc,
                              uword* handler_sp,
                              uword* handler_fp) {
   // TODO(turnidge): Is there a faster way to get the next entry frame?
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
@@ skipping 49 matching lines @@
   uword current_sp = reinterpret_cast<uword>(&program_counter) - 1024;
   __asan_unpoison_memory_region(reinterpret_cast<void*>(current_sp),
                                 stack_pointer - current_sp);
   func(program_counter, stack_pointer, frame_pointer,
        raw_exception, raw_stacktrace);
 #endif
   UNREACHABLE();
 }
 
 
+static RawField* LookupStacktraceField(const Instance& instance) {
+  Isolate* isolate = Isolate::Current();
+  Class& error_class = Class::Handle(isolate,
+                                     isolate->object_store()->error_class());
+  if (error_class.IsNull()) {
+    const Library& core_lib = Library::Handle(isolate, Library::CoreLibrary());
+    error_class = core_lib.LookupClass(Symbols::Error(), NULL);
+    ASSERT(!error_class.IsNull());
+    isolate->object_store()->set_error_class(error_class);
+  }
+  const Class& instance_class = Class::Handle(isolate, instance.clazz());
+  Error& malformed_type_error = Error::Handle(isolate);
+  if (instance_class.IsSubtypeOf(Object::null_abstract_type_arguments(),
+                                 error_class,
+                                 Object::null_abstract_type_arguments(),
+                                 &malformed_type_error)) {
+    ASSERT(malformed_type_error.IsNull());
+    return error_class.LookupInstanceField(Symbols::_stackTrace());
+  }
+  return Field::null();
+}
+
+
 static void ThrowExceptionHelper(const Instance& incoming_exception,
                                  const Instance& existing_stacktrace) {
   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;
   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;
+    const Field& stacktrace_field =
+        Field::Handle(LookupStacktraceField(incoming_exception));
+    bool full_stacktrace = !stacktrace_field.IsNull();
+    RegularStacktraceBuilder frame_builder(full_stacktrace);
     handler_exists = FindExceptionHandler(&handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &frame_builder);
+    // Create arrays for function, code and pc_offset triplet of 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 (!stacktrace_field.IsNull()) {
+      // This is an error object and we need to capture the full stack trace
+      // here implicitly, so we set up the stack trace. The stack trace field
+      // is set only once, it is not overriden.
+      const Array& catch_func_array =
+          Array::Handle(isolate,
+                        Array::MakeArray(frame_builder.catch_func_list()));
+      const Array& catch_code_array =
+          Array::Handle(isolate,
+                        Array::MakeArray(frame_builder.catch_code_list()));
+      const Array& catch_pc_offset_array =
+          Array::Handle(isolate,
+                        Array::MakeArray(frame_builder.catch_pc_offset_list()));
+      stacktrace = Stacktrace::New(func_array, code_array, pc_offset_array);
+      stacktrace.SetCatchStacktrace(catch_func_array,
+                                    catch_code_array,
+                                    catch_pc_offset_array);
+      if (incoming_exception.GetField(stacktrace_field) == Object::null()) {
+        incoming_exception.SetField(stacktrace_field, stacktrace);
+      }
+    }
     // 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 (pc_offset_array.Length() != 0) {
       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);
         // Since we are re throwing and appending to the existing stack trace
         // we clear out the catch trace collected in the existing stack trace
         // as that trace will not be valid anymore.
         stacktrace.SetCatchStacktrace(Object::empty_array(),
                                       Object::empty_array(),
@@ skipping 72 matching lines @@
   const String& cls_name = String::Handle(Symbols::New(class_name));
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   // No ambiguity error expected: passing NULL.
   Class& cls = Class::Handle(core_lib.LookupClass(cls_name, NULL));
   ASSERT(!cls.IsNull());
   // There are no parameterized error types, so no need to set type arguments.
   return Instance::New(cls);
 }
 
 
-// Assign the value to the field given by its name in the given instance.
-void Exceptions::SetField(const Instance& instance,
-                          const Class& cls,
-                          const char* field_name,
-                          const Object& value) {
-  const Field& field = Field::Handle(cls.LookupInstanceField(
-      String::Handle(Symbols::New(field_name))));
-  ASSERT(!field.IsNull());
-  instance.SetField(field, value);
-}
-
-
 // Allocate, initialize, and throw a TypeError.
 void Exceptions::CreateAndThrowTypeError(intptr_t location,
                                          const String& src_type_name,
                                          const String& dst_type_name,
                                          const String& dst_name,
                                          const String& malformed_error) {
   const Array& args = Array::Handle(Array::New(8));
 
   ExceptionType exception_type =
       dst_name.Equals(kCastErrorDstName) ? kCast : kType;
@@ skipping 114 matching lines @@
   Throw(stack_overflow);
 }
 
 
 RawObject* Exceptions::Create(ExceptionType type, const Array& arguments) {
   Library& library = Library::Handle();
   const String* class_name = NULL;
   const String* constructor_name = &Symbols::Dot();
   switch (type) {
     case kNone:
+    case kStackOverflow:
+    case kOutOfMemory:
       UNREACHABLE();
       break;
     case kRange:
       library = Library::CoreLibrary();
       class_name = &Symbols::RangeError();
       break;
     case kArgument:
       library = Library::CoreLibrary();
       class_name = &Symbols::ArgumentError();
       break;
     case kNoSuchMethod:
       library = Library::CoreLibrary();
       class_name = &Symbols::NoSuchMethodError();
       constructor_name = &String::Handle(Symbols::New("._withType"));
       break;
     case kFormat:
       library = Library::CoreLibrary();
       class_name = &Symbols::FormatException();
       break;
     case kUnsupported:
       library = Library::CoreLibrary();
       class_name = &Symbols::UnsupportedError();
       break;
-    case kStackOverflow:
-      library = Library::CoreLibrary();
-      class_name = &Symbols::StackOverflowError();
-      break;
-    case kOutOfMemory:
-      library = Library::CoreLibrary();
-      class_name = &Symbols::OutOfMemoryError();
-      break;
     case kInternalError:
       library = Library::CoreLibrary();
       class_name = &Symbols::InternalError();
       break;
     case kNullThrown:
       library = Library::CoreLibrary();
       class_name = &Symbols::NullThrownError();
       break;
     case kIsolateSpawn:
       library = Library::IsolateLibrary();
@@ skipping 37 matching lines @@
       break;
   }
 
   return DartLibraryCalls::InstanceCreate(library,
                                           *class_name,
                                           *constructor_name,
                                           arguments);
 }
 
 }  // namespace dart