Code patching support and tests for new inline caches.

runtime/vm/code_patcher_ia32.cc

 // Copyright (c) 2011, 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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/cpu.h"
 #include "vm/ic_data.h"
 #include "vm/instructions.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 
 namespace dart {
 
 // The pattern of a Dart call is:
 //  1: mov ECX, immediate 1
 //  2: mov EDX, immediate 2
 //  3: call target_address
 //  <- return_address
 class DartCallPattern : public ValueObject {
- private:
-  static const int kNumInstructions = 3;
-  static const int kInstructionSize = 5;  // All instructions have same length.
-
  public:
   explicit DartCallPattern(uword return_address)
       : start_(return_address - (kNumInstructions * kInstructionSize)) {
     ASSERT(*reinterpret_cast<uint8_t*>(start_) == 0xB9);
     ASSERT(*reinterpret_cast<uint8_t*>(start_ + 1 * kInstructionSize) == 0xBA);
     ASSERT(*reinterpret_cast<uint8_t*>(start_ + 2 * kInstructionSize) == 0xE8);
     ASSERT(kInstructionSize == Assembler::kCallExternalLabelSize);
   }
 
   uword target() const {
     const uword offset = *reinterpret_cast<uword*>(call_address() + 1);
     return return_address() + offset;
   }
 
   void set_target(uword target) const {
     uword* target_addr = reinterpret_cast<uword*>(call_address() + 1);
     uword offset = target - return_address();
     *target_addr = offset;
     CPU::FlushICache(call_address(), kInstructionSize);
   }
 
   uint32_t immediate_one() const {
     return *reinterpret_cast<uint32_t*>(start_ + 1);
   }
 
+  void set_immediate_one(uint32_t value) {
+    uint32_t* target_addr = reinterpret_cast<uint32_t*>(start_ + 1);
+    *target_addr = value;
+    CPU::FlushICache(call_address(), kInstructionSize);
+  }
+
   uint32_t immediate_two() const {
     return *reinterpret_cast<uint32_t*>(start_ + kInstructionSize + 1);
   }
 
   int argument_count() const {
     Array& args_desc = Array::Handle();
     args_desc ^= reinterpret_cast<RawObject*>(immediate_two());
     Smi& num_args = Smi::Handle();
     num_args ^= args_desc.At(0);
     return num_args.Value();
   }
 
   int named_argument_count() const {
     Array& args_desc = Array::Handle();
     args_desc ^= reinterpret_cast<RawObject*>(immediate_two());
     Smi& num_args = Smi::Handle();
     num_args ^= args_desc.At(0);
     Smi& num_pos_args = Smi::Handle();
     num_pos_args ^= args_desc.At(1);
     return num_args.Value() - num_pos_args.Value();
   }
 
+  static const int kNumInstructions = 3;
+  static const int kInstructionSize = 5;  // All instructions have same length.
+
  private:
   uword return_address() const {
     return start_ + kNumInstructions * kInstructionSize;
   }
 
   uword call_address() const {
     return start_ + 2 * kInstructionSize;
   }
 
   uword start_;
@@ skipping 31 matching lines @@
  public:
   explicit InstanceCall(uword return_address)
       : DartCallPattern(return_address) {}
 
   RawArray* ic_data() const {
     Array& array = Array::Handle();
     array ^= reinterpret_cast<RawObject*>(immediate_one());
     return array.raw();
   }
 
+  void SetIcData(const Array& value) {
+    set_immediate_one(reinterpret_cast<int32_t>(value.raw()));
+  }
+
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceCall);
 };
 
 
 void CodePatcher::GetStaticCallAt(uword return_address,
                                   Function* function,
                                   uword* target) {
   ASSERT(function != NULL);
   ASSERT(target != NULL);
@@ skipping 112 matching lines @@
   ICData ic_data(Array::ZoneHandle(call.ic_data()));
   *function_name = ic_data.FunctionName();
 }
 
 
 void CodePatcher::PatchInstanceCallAt(uword return_address, uword new_target) {
   InstanceCall call(return_address);
   call.set_target(new_target);
 }
 
+
+RawArray* CodePatcher::GetInstanceCallIcDataAt(uword return_address) {
+  InstanceCall call(return_address);
+  return call.ic_data();
+}
+
+
+void CodePatcher::SetInstanceCallIcDataAt(uword return_address,
+                                          const Array& ic_data) {
+  InstanceCall call(return_address);
+  call.SetIcData(ic_data);
+}
+
+
+intptr_t CodePatcher::InstanceCallSizeInBytes() {
+  return DartCallPattern::kNumInstructions * DartCallPattern::kInstructionSize;
+}
+
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32