Fix debugger stub patching on x64 architecture

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 167 matching lines @@
             function.SwitchToUnoptimizedCode();
           }
         }
       }
     }
   }
 }
 
 
 void Debugger::InstrumentForStepping(const Function& target_function) {
+  //printf("Instrumenting: %s\n", target_function.ToFullyQualifiedCString());
   if (target_function.is_native()) {
     // Can't instrument native functions.
     return;
   }
   if (!target_function.HasCode()) {
     Compiler::CompileFunction(target_function);
     // If there were any errors, ignore them silently and return without
     // adding breakpoints to target.
     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.
+//printf("IFS: found bp i %ld  pc 0x%lx\n", i, desc.PC(i));
+        bpt->Enable();
+        continue;
+      }
+//printf("IFS: make new bp i %ld  pc 0x%lx\n", i, desc.PC(i));
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
@@ skipping 302 matching lines @@
 }
 
 
 void Debugger::MakeCodeBreakpointsAt(const Function& func,
                                      SourceBreakpoint* bpt) {
   ASSERT((bpt != NULL) && bpt->IsResolved());
   ASSERT(!func.HasOptimizedCode());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
+//printf("XXX make code bp at %ld\n", bpt->token_pos_);
   for (intptr_t i = 0; i < desc.Length(); i++) {
     intptr_t desc_token_pos = desc.TokenPos(i);
     if ((desc_token_pos == bpt->token_pos_) &&
         IsSafePoint(desc.DescriptorKind(i))) {
+//printf("XXX found matching safe point i %ld pos %ld\n", i, desc_token_pos);
       CodeBreakpoint* code_bpt = GetCodeBreakpoint(desc.PC(i));
       if (code_bpt == NULL) {
+//printf("making new code breakpoint\n");
         // No code breakpoint for this code exists; create one.
         code_bpt = new CodeBreakpoint(func, i);
         RegisterCodeBreakpoint(code_bpt);
       }
-      code_bpt->set_src_bpt(bpt);
+//else printf("found existing code breakpoint pc 0x%lx srcbp 0x%p\n", code_bpt->pc(), code_bpt->src_bpt());
+//      code_bpt->set_src_bpt(bpt);
       if (bpt->IsEnabled()) {
         code_bpt->Enable();
       }
     }
   }
 }
 
 
 void Debugger::FindEquivalentFunctions(const Script& script,
                                        intptr_t start_pos,
@@ skipping 171 matching lines @@
                               func.token_pos(),
                               func.end_token_pos(),
                               &functions);
       const intptr_t num_functions = functions.Length();
       // We must have found at least one function: func.
       ASSERT(num_functions > 0);
       // Create code breakpoints for all compiled functions we found.
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
         if (func.HasCode()) {
+//printf("func %s\n", func.ToFullyQualifiedCString());
           MakeCodeBreakpointsAt(func, bpt);
         }
       }
       bpt->Enable();
       SignalBpResolved(bpt);
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
@@ skipping 598 matching lines @@
     if (bpt->pc() == breakpoint_address) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
 uword Debugger::GetPatchedStubAddress(uword breakpoint_address) {
+//printf("GPSA 0x%lx\n", 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 36 matching lines @@
 }
 
 
 // Remove and delete internal breakpoints, i.e. breakpoints that
 // are not associated with a source breakpoint.
 void Debugger::RemoveInternalBreakpoints() {
   CodeBreakpoint* prev_bpt = NULL;
   CodeBreakpoint* curr_bpt = code_breakpoints_;
   while (curr_bpt != NULL) {
     if (curr_bpt->src_bpt() == NULL) {
+//printf("RIBP for 0x%lx\n", curr_bpt->pc());
       if (prev_bpt == NULL) {
         code_breakpoints_ = code_breakpoints_->next();
       } else {
         prev_bpt->set_next(curr_bpt->next());
       }
       CodeBreakpoint* temp_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
       temp_bpt->Disable();
       delete temp_bpt;
     } else {
@@ skipping 36 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart