Pattern match on generated code to find edge counters.

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 124 matching lines @@
     // No need to flush the instruction cache, since the code is not modified.
   }
 
  private:
   uword start_;
   const Array& object_pool_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCall);
 };
 
 
-// The expected code pattern of a dart closure call:
+// The expected code pattern of a Dart closure call:
 //  00: 49 ba imm64     mov R10, immediate 2      ; 10 bytes
 //  10: 4d 8b 9f imm32  mov R11, [PP + off]
 //  17: 41 ff d3        call R11                  ; 3 bytes
 //  20: <- return_address
 class ClosureCall : public ValueObject {
  public:
   explicit ClosureCall(uword return_address)
       : start_(return_address - kCallPatternSize) {
     ASSERT(IsValid(return_address));
   }
@@ skipping 85 matching lines @@
   ASSERT(code.ContainsInstructionAt(return_address));
   UnoptimizedStaticCall static_call(return_address, code);
   ICData& ic_data = ICData::Handle();
   ic_data ^= static_call.ic_data();
   if (ic_data_result != NULL) {
     *ic_data_result = ic_data.raw();
   }
   return ic_data.GetTargetAt(0);
 }
 
+
+// The expected code pattern of an edge counter in unoptimized code:
+//  49 8b 87 imm32    mov RAX, [PP + offset]
+class EdgeCounter : public ValueObject {
+ public:
+  EdgeCounter(uword pc, const Code& code)
+      : end_(pc - kAdjust), object_pool_(Array::Handle(code.ObjectPool())) {
+    ASSERT(IsValid(end_));
+  }
+
+  static bool IsValid(uword end) {
+    uint8_t* bytes = reinterpret_cast<uint8_t*>(end - 7);
+    return (bytes[0] == 0x49) && (bytes[1] == 0x8b) && (bytes[2] == 0x87);
+  }
+
+  RawObject* edge_counter() const {
+    return object_pool_.At(InstructionPattern::IndexFromPPLoad(end_ - 4));
+  }
+
+ private:
+  // The edge counter load is followed by the fixed-size edge counter
+  // incrementing code:
+  //     49 c7 c3 02 00 00 00         movq r11,0x2
+  //     4c 01 58 17                  addq [rax+0x17],r11

[sra1, 2013/09/30 16:23:08]

This is pattern matching the poor encoding of addq.
Perhaps it would beworth fixing addq first
See http://dartbug.com/13681

+  static const intptr_t kAdjust = 11;
+
+  uword end_;
+  const Array& object_pool_;
+};
+
+
+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