Consolidate debug stubs

runtime/vm/debugger.cc

 // Copyright (c) 2012, 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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 570 matching lines @@
 void DebuggerStackTrace::AddActivation(ActivationFrame* frame) {
   trace_.Add(frame);
 }
 
 
 static bool IsSafePoint(PcDescriptors::Kind kind) {
   return ((kind == PcDescriptors::kIcCall) ||
           (kind == PcDescriptors::kFuncCall) ||
           (kind == PcDescriptors::kClosureCall) ||
           (kind == PcDescriptors::kReturn) ||
-          (kind == PcDescriptors::kEqualNull));
+          (kind == PcDescriptors::kRuntimeCall));
 }
 
 
 CodeBreakpoint::CodeBreakpoint(const Function& func, intptr_t pc_desc_index)
     : function_(func.raw()),
       pc_desc_index_(pc_desc_index),
       pc_(0),
       line_number_(-1),
       is_enabled_(false),
       src_bpt_(NULL),
@@ skipping 63 matching lines @@
     }
     case PcDescriptors::kFuncCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       saved_bytes_.target_address_ =
           CodePatcher::GetStaticCallTargetAt(pc_, code);
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      StubCode::BreakpointStaticEntryPoint());
       break;
     }
+    case PcDescriptors::kRuntimeCall:
     case PcDescriptors::kClosureCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       saved_bytes_.target_address_ =
           CodePatcher::GetStaticCallTargetAt(pc_, code);
       CodePatcher::PatchStaticCallAt(pc_, code,
-                                     StubCode::BreakpointClosureEntryPoint());
-      break;
-    }
-    case PcDescriptors::kEqualNull: {
-      const Code& code =
-          Code::Handle(Function::Handle(function_).unoptimized_code());
-      saved_bytes_.target_address_ =
-          CodePatcher::GetStaticCallTargetAt(pc_, code);
-      CodePatcher::PatchStaticCallAt(pc_, code,
-                                     StubCode::BreakpointEqNullEntryPoint());
+                                     StubCode::BreakpointRuntimeEntryPoint());
       break;
     }
     case PcDescriptors::kReturn:
       PatchFunctionReturn();
       break;
     default:
       UNREACHABLE();
   }
   is_enabled_ = true;
 }
 
 
 void CodeBreakpoint::RestoreCode() {
   ASSERT(is_enabled_);
   switch (breakpoint_kind_) {
     case PcDescriptors::kIcCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchInstanceCallAt(pc_, code,
                                        saved_bytes_.target_address_);
       break;
     }
     case PcDescriptors::kFuncCall:
     case PcDescriptors::kClosureCall:
-    case PcDescriptors::kEqualNull: {
+    case PcDescriptors::kRuntimeCall: {
       const Code& code =
           Code::Handle(Function::Handle(function_).unoptimized_code());
       CodePatcher::PatchStaticCallAt(pc_, code,
                                      saved_bytes_.target_address_);
       break;
     }
     case PcDescriptors::kReturn:
       RestoreFunctionReturn();
       break;
     default:
@@ skipping 885 matching lines @@
           Function& closure_func =
               Function::Handle(Closure::function(Instance::Cast(receiver)));
           if (IsDebuggable(closure_func)) {
             func_to_instrument = closure_func.raw();
           }
         }
         // If the receiver is not a closure, then the runtime will attempt
         // to invoke the "call" method on the object if one exists.
         // TODO(hausner): find call method and intrument it for stepping.
       }
-    } else if (bpt->breakpoint_kind_ == PcDescriptors::kEqualNull) {
+    } else if (bpt->breakpoint_kind_ == PcDescriptors::kRuntimeCall) {
       // This is just a call to the runtime, not Dart code. Stepping
       // into not possible, just treat like StepOver.
       func_to_instrument = bpt->function();
     } else {
       ASSERT(bpt->breakpoint_kind_ == PcDescriptors::kReturn);
       // Treat like stepping out to caller.
       if (stack_trace->Length() > 1) {
         ActivationFrame* caller_frame = stack_trace->ActivationFrameAt(1);
         func_to_instrument = caller_frame->function().raw();
       }
@@ skipping 61 matching lines @@
         if (FLAG_verbose_debug) {
           OS::Print("Resetting pending breakpoint to function %s\n",
                     closure.ToFullyQualifiedCString());
         }
         bpt->set_function(closure);
       } else {
         if (FLAG_verbose_debug) {
           OS::Print("Enable pending breakpoint for function '%s'\n",
                     String::Handle(lookup_function.name()).ToCString());
         }
+        const Script& script= Script::Handle(func.script());
+        intptr_t first_pos, last_pos;
+        script.TokenRangeAtLine(bpt->LineNumber(), &first_pos, &last_pos);
         intptr_t bp_pos =
-            ResolveBreakpointPos(func, bpt->token_pos(), func.end_token_pos());
+            ResolveBreakpointPos(func, bpt->token_pos(), last_pos);
         bpt->set_token_pos(bp_pos);
         MakeCodeBreakpointsAt(func, bp_pos, bpt);
         SignalBpResolved(bpt);
       }
       bpt->Enable();  // Enables the code breakpoint as well.
     }
     bpt = bpt->next();
   }
 }
 
 
 CodeBreakpoint* Debugger::GetCodeBreakpoint(uword breakpoint_address) {
   CodeBreakpoint* bpt = code_breakpoints_;
   while (bpt != NULL) {
     if (bpt->pc() == breakpoint_address) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
+uword Debugger::GetPatchedStubAddress(uword breakpoint_address) {
+  CodeBreakpoint* bpt = GetCodeBreakpoint(breakpoint_address);
+  if (bpt != NULL) {
+    return bpt->saved_bytes_.target_address_;

[siva, 2013/05/23 01:11:26]

Is bpt->saved_bytes_.target_address_ a Smi always?

I didn't see any code that does the shift so I am assuming this code is hoping
that the target_address_ is always even aligned.

[hausner, 2013/05/23 18:32:12]

Yes, we depend on the fact that target addresses of stubs are aligned. See
assertion in code_generator.cc.

+  }
+  UNREACHABLE();
+  return NULL;
+}
+
+
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   SourceBreakpoint* prev_bpt = NULL;
   SourceBreakpoint* curr_bpt = src_breakpoints_;
   while (curr_bpt != NULL) {
     if (curr_bpt->id() == bp_id) {
       if (prev_bpt == NULL) {
         src_breakpoints_ = src_breakpoints_->next();
       } else {
@@ skipping 87 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart