VM: Set breakpoints on x64 and arm64 without patching code.

runtime/vm/code_patcher_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/cpu.h"
@@ skipping 84 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(UnoptimizedStaticCall);
 };
 
 
 // The expected pattern of a call where the target is loaded from
 // the object pool:
 //   0: 41 ff 97 imm32  call [PP + off]
 //   7: <- return address
 class PoolPointerCall : public ValueObject {
  public:
-  explicit PoolPointerCall(uword return_address)
-      : start_(return_address - kCallPatternSize) {
+  explicit PoolPointerCall(uword return_address, const Code& code)
+      : start_(return_address - kCallPatternSize),
+        object_pool_(Array::Handle(code.ObjectPool())) {
     ASSERT(IsValid(return_address));
   }
 
   static const int kCallPatternSize = 7;
 
   static bool IsValid(uword return_address) {
     uint8_t* code_bytes =
         reinterpret_cast<uint8_t*>(return_address - kCallPatternSize);
     return (code_bytes[0] == 0x41) && (code_bytes[1] == 0xFF) &&
            (code_bytes[2] == 0x97);
   }
 
-  int32_t pp_offset() const {
-    return *reinterpret_cast<int32_t*>(start_ + 3);
+  intptr_t pp_index() const {
+    return InstructionPattern::IndexFromPPLoad(start_ + 3);
   }
 
-  void set_pp_offset(int32_t offset) const {
-    *reinterpret_cast<int32_t*>(start_ + 3) = offset;
-    CPU::FlushICache(start_, kCallPatternSize);
+  uword Target() const {
+    return reinterpret_cast<uword>(object_pool_.At(pp_index()));
+  }
+
+  void SetTarget(uword target) const {
+    const Smi& smi = Smi::Handle(reinterpret_cast<RawSmi*>(target));
+    object_pool_.SetAt(pp_index(), smi);
+    // No need to flush the instruction cache, since the code is not modified.
   }
 
  protected:
   uword start_;
+  const Array& object_pool_;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PoolPointerCall);
 };
 
 
-// The expected pattern of a dart static call:
-//   0: 41 ff 97 imm32  call [PP + off]
-//   7: <- return address
-class StaticCall : public PoolPointerCall {
- public:
-  StaticCall(uword return_address, const Code& code)
-      : PoolPointerCall(return_address),
-        object_pool_(Array::Handle(code.ObjectPool())) {
-    ASSERT(IsValid(return_address));
-    ASSERT(kCallPatternSize == Assembler::kCallExternalLabelSize);
-  }
-
-  uword target() const {
-    intptr_t index = InstructionPattern::IndexFromPPLoad(start_ + 3);
-    return reinterpret_cast<uword>(object_pool_.At(index));
-  }
-
-  void set_target(uword target) const {
-    intptr_t index = InstructionPattern::IndexFromPPLoad(start_ + 3);
-    const Smi& smi = Smi::Handle(reinterpret_cast<RawSmi*>(target));
-    object_pool_.SetAt(index, smi);
-    // No need to flush the instruction cache, since the code is not modified.
-  }
-
- private:
-  const Array& object_pool_;
-  DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCall);
-};
-
-
 uword CodePatcher::GetStaticCallTargetAt(uword return_address,
                                          const Code& code) {
   ASSERT(code.ContainsInstructionAt(return_address));
-  StaticCall call(return_address, code);
-  return call.target();
+  PoolPointerCall call(return_address, code);
+  return call.Target();
 }
 
 
 void CodePatcher::PatchStaticCallAt(uword return_address,
                                     const Code& code,
                                     uword new_target) {
-  ASSERT(code.ContainsInstructionAt(return_address));
-  StaticCall call(return_address, code);
-  call.set_target(new_target);
+  PatchPoolPointerCallAt(return_address, code, new_target);
 }
 
 
-int32_t CodePatcher::GetPoolOffsetAt(uword return_address) {
-  PoolPointerCall call(return_address);
-  return call.pp_offset();
+void CodePatcher::PatchPoolPointerCallAt(uword return_address,
+                                         const Code& code,
+                                         uword new_target) {
+  ASSERT(code.ContainsInstructionAt(return_address));
+  PoolPointerCall call(return_address, code);
+  call.SetTarget(new_target);
 }
 
 
-void CodePatcher::SetPoolOffsetAt(uword return_address, int32_t offset) {
-  PoolPointerCall call(return_address);
-  call.set_pp_offset(offset);
-}
-
-
 void CodePatcher::PatchInstanceCallAt(uword return_address,
                                       const Code& code,
                                       uword new_target) {
   ASSERT(code.ContainsInstructionAt(return_address));
   InstanceCall call(return_address, code);
   call.set_target(new_target);
 }
 
 
 uword CodePatcher::GetInstanceCallAt(uword return_address,
@@ skipping 63 matching lines @@
 
 RawObject* CodePatcher::GetEdgeCounterAt(uword pc, const Code& code) {
   ASSERT(code.ContainsInstructionAt(pc));
   EdgeCounter counter(pc, code);
   return counter.edge_counter();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64