Revert change 19074 until the windows build is fixed.

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,
-                                 StacktraceBuilder* builder) {
+                                 const GrowableObjectArray& func_list,
+                                 const GrowableObjectArray& code_list,
+                                 const GrowableObjectArray& pc_offset_list) {
   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());
-            builder->AddFrame(func, code, offset);
+            func_list.Add(func);
+            code_list.Add(code);
+            pc_offset_list.Add(offset);
           }
         }
       } else {
         offset = Smi::New(frame->pc() - code.EntryPoint());
         func = code.function();
         if (ShouldShowFunction(func)) {
-          builder->AddFrame(func, code, offset);
+          func_list.Add(func);
+          code_list.Add(code);
+          pc_offset_list.Add(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) {
-  bool use_preallocated_stacktrace = false;
-  Isolate* isolate = Isolate::Current();
-  Instance& exception = Instance::Handle(isolate, incoming_exception.raw());
+  Instance& exception = Instance::Handle(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(
-        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();
-    }
-  }
+  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);
   // 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