Version 1.1.1 (stable channel)

dart/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 690 matching lines @@
 
 
 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),
       next_(NULL) {
+  saved_value_ = 0;
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());  // Function must be compiled.
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   ASSERT(pc_desc_index < desc.Length());
   token_pos_ = desc.TokenPos(pc_desc_index);
   ASSERT(token_pos_ >= 0);
   pc_ = desc.PC(pc_desc_index);
   ASSERT(pc_ != 0);
   breakpoint_kind_ = desc.DescriptorKind(pc_desc_index);
@@ skipping 30 matching lines @@
 intptr_t CodeBreakpoint::LineNumber() {
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(SourceCode());
     script.GetTokenLocation(token_pos_, &line_number_, NULL);
   }
   return line_number_;
 }
 
 
-void CodeBreakpoint::PatchCode() {
-  ASSERT(!is_enabled_);
-  switch (breakpoint_kind_) {
-    case PcDescriptors::kIcCall: {
-      const Code& code =
-          Code::Handle(Function::Handle(function_).unoptimized_code());
-      saved_bytes_.target_address_ =
-          CodePatcher::GetInstanceCallAt(pc_, code, NULL);
-      CodePatcher::PatchInstanceCallAt(pc_, code,
-                                       StubCode::BreakpointDynamicEntryPoint());
-      break;
-    }
-    case PcDescriptors::kUnoptStaticCall: {
-      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:
-    case PcDescriptors::kReturn: {
-      const Code& code =
-          Code::Handle(Function::Handle(function_).unoptimized_code());
-      saved_bytes_.target_address_ =
-          CodePatcher::GetStaticCallTargetAt(pc_, code);
-      CodePatcher::PatchStaticCallAt(pc_, code,
-                                     StubCode::BreakpointRuntimeEntryPoint());
-      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::kUnoptStaticCall:
-    case PcDescriptors::kClosureCall:
-    case PcDescriptors::kRuntimeCall:
-    case PcDescriptors::kReturn: {
-      const Code& code =
-          Code::Handle(Function::Handle(function_).unoptimized_code());
-      CodePatcher::PatchStaticCallAt(pc_, code,
-                                     saved_bytes_.target_address_);
-      break;
-    }
-    default:
-      UNREACHABLE();
-  }
-  is_enabled_ = false;
-}
-
-
 void CodeBreakpoint::Enable() {
   if (!is_enabled_) {
     PatchCode();
   }
   ASSERT(is_enabled_);
 }
 
 
 void CodeBreakpoint::Disable() {
   if (is_enabled_) {
@@ skipping 185 matching lines @@
     if (!target_function.HasCode()) {
       return;
     }
   }
   DeoptimizeWorld();
   ASSERT(!target_function.HasOptimizedCode());
   Code& code = Code::Handle(target_function.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
   for (intptr_t i = 0; i < desc.Length(); i++) {
-    CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
-    if (bpt != NULL) {
-      // There is already a breakpoint for this address. Make sure
-      // it is enabled.
-      bpt->Enable();
-      continue;
-    }
     if (IsSafePoint(desc.DescriptorKind(i))) {
+      CodeBreakpoint* bpt = GetCodeBreakpoint(desc.PC(i));
+      if (bpt != NULL) {
+        // There is already a breakpoint for this address. Make sure
+        // it is enabled.
+        bpt->Enable();
+        continue;
+      }
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
@@ skipping 1118 matching lines @@
     }
     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_;
+    return bpt->OrigStubAddress();
   }
   UNREACHABLE();
   return 0L;
 }
 
 
 // Remove and delete the source breakpoint bpt and its associated
 // code breakpoints.
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   SourceBreakpoint* prev_bpt = NULL;
@@ skipping 92 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart