Avoid instantiating even a stub stacktrace when neither the catch clause nor the

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 394 matching lines @@
     }
   } else {
     // Get stacktrace field of class Error.
     const Field& stacktrace_field =
         Field::Handle(isolate, LookupStacktraceField(exception));
     handler_exists = FindExceptionHandler(isolate,
                                           &handler_pc,
                                           &handler_sp,
                                           &handler_fp,
                                           &handler_needs_stacktrace);
-    Array& code_array = Array::Handle(isolate, Object::empty_array().raw());
-    Array& pc_offset_array =
-        Array::Handle(isolate, Object::empty_array().raw());
-    // If we have an error with a stacktrace field then collect the full stack
-    // trace and store it into the field.
-    if (!stacktrace_field.IsNull()) {
-      if (exception.GetField(stacktrace_field) == Object::null()) {
-        // 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 Stacktrace& full_stacktrace =
-            Stacktrace::Handle(isolate, Exceptions::CurrentStacktrace());
-        exception.SetField(stacktrace_field, full_stacktrace);
+    if (!stacktrace_field.IsNull() || handler_needs_stacktrace) {
+      Array& code_array = Array::Handle(isolate, Object::empty_array().raw());
+      Array& pc_offset_array =
+          Array::Handle(isolate, Object::empty_array().raw());
+      // If we have an error with a stacktrace field then collect the full stack
+      // trace and store it into the field.
+      if (!stacktrace_field.IsNull()) {
+        if (exception.GetField(stacktrace_field) == Object::null()) {
+          // 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 Stacktrace& full_stacktrace =
+              Stacktrace::Handle(isolate, Exceptions::CurrentStacktrace());
+          exception.SetField(stacktrace_field, full_stacktrace);
+        }
       }
-    }
-    if (handler_needs_stacktrace) {
-      RegularStacktraceBuilder frame_builder(false);
-      BuildStackTrace(isolate, &frame_builder);
+      if (handler_needs_stacktrace) {
+        RegularStacktraceBuilder frame_builder(false);
+        BuildStackTrace(isolate, &frame_builder);
 
-      // Create arrays for code and pc_offset tuples of each frame.
-      code_array = Array::MakeArray(frame_builder.code_list());
-      pc_offset_array = Array::MakeArray(frame_builder.pc_offset_list());
-    }
-    if (existing_stacktrace.IsNull()) {
-      stacktrace = Stacktrace::New(code_array, pc_offset_array);
-    } else {
-      ASSERT(is_rethrow);
-      stacktrace ^= existing_stacktrace.raw();
-      if (pc_offset_array.Length() != 0) {
-        // Skip the first frame during a rethrow. This is the catch clause with
-        // the rethrow statement, which is not part of the original trace a
-        // rethrow is supposed to preserve.
-        stacktrace.Append(code_array, pc_offset_array, 1);
+        // Create arrays for code and pc_offset tuples of each frame.
+        code_array = Array::MakeArray(frame_builder.code_list());
+        pc_offset_array = Array::MakeArray(frame_builder.pc_offset_list());
       }
-      // 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());
+      if (existing_stacktrace.IsNull()) {
+        stacktrace = Stacktrace::New(code_array, pc_offset_array);
+      } else {
+        ASSERT(is_rethrow);
+        stacktrace ^= existing_stacktrace.raw();
+        if (pc_offset_array.Length() != 0) {
+          // Skip the first frame during a rethrow. This is the catch clause
+          // with the rethrow statement, which is not part of the original
+          // trace a rethrow is supposed to preserve.
+          stacktrace.Append(code_array, pc_offset_array, 1);
+        }
+        // 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());
+      }
     }
   }
   // 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);
 
   if (FLAG_print_stacktrace_at_throw) {
     OS::Print("Exception '%s' thrown:\n", exception.ToCString());
@@ skipping 284 matching lines @@
 
 // Throw JavascriptCompatibilityError exception.
 void Exceptions::ThrowJavascriptCompatibilityError(const char* msg) {
   const Array& exc_args = Array::Handle(Array::New(1));
   const String& msg_str = String::Handle(String::New(msg));
   exc_args.SetAt(0, msg_str);
   Exceptions::ThrowByType(Exceptions::kJavascriptCompatibilityError, exc_args);
 }
 
 }  // namespace dart