Address review comments.

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_entry.h"
 #include "vm/debugger.h"
 #include "vm/flags.h"
 #include "vm/object.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.");
 
 
 const char* Exceptions::kCastExceptionDstName = "type cast";
 
 
 // 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,
-                                 GrowableArray<uword>* stack_frame_pcs,
                                  const GrowableObjectArray& func_list,
-                                 const GrowableObjectArray& code_list) {
+                                 const GrowableObjectArray& code_list,
+                                 const GrowableObjectArray& pc_offset_list) {
   StackFrameIterator frames(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = frames.NextFrame();
   ASSERT(frame != NULL);
   Function& func = Function::Handle();
   Code& code = Code::Handle();
+  Smi& offset = Smi::Handle();
   while (!frame->IsEntryFrame()) {
     if (frame->IsDartFrame()) {
-      stack_frame_pcs->Add(frame->pc());
       func = frame->LookupDartFunction();
       code = frame->LookupDartCode();
+      offset = Smi::New(frame->pc() - code.EntryPoint());
       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);
   }
   ASSERT(frame->IsEntryFrame());
@@ skipping 81 matching lines @@
 static void ThrowExceptionHelper(const Instance& incoming_exception,
                                  const Instance& existing_stacktrace) {
   Instance& exception = Instance::Handle(incoming_exception.raw());
   if (exception.IsNull()) {
     GrowableArray<const Object*> arguments;
     exception ^= Exceptions::Create(Exceptions::kNullPointer, arguments);
   }
   uword handler_pc = 0;
   uword handler_sp = 0;
   uword handler_fp = 0;
-  GrowableArray<uword> stack_frame_pcs;
   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,
-                                             &stack_frame_pcs,
                                              func_list,
-                                             code_list);
+                                             code_list,
+                                             pc_offset_list);
   // 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 (!stack_frame_pcs.is_empty()) {
+  if (pc_offset_list.Length() != 0) {
     if (existing_stacktrace.IsNull()) {
-      stacktrace = Stacktrace::New(stack_frame_pcs, func_list, code_list);
+      stacktrace = Stacktrace::New(func_list, code_list, pc_offset_list);
     } else {
       stacktrace ^= existing_stacktrace.raw();
-      stacktrace.Append(stack_frame_pcs, func_list, code_list);
+      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.
@@ skipping 255 matching lines @@
     case kIsolateSpawn:
       library = Library::IsolateLibrary();
       class_name = Symbols::New("IsolateSpawnException");
       break;
   }
 
   return DartLibraryCalls::ExceptionCreate(library, class_name, arguments);
 }
 
 }  // namespace dart