VM: Link native calls lazily.

runtime/vm/code_patcher_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/cpu.h"
@@ skipping 26 matching lines @@
   }
 
   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();
+    WritableInstructionsScope writable(reinterpret_cast<uword>(target_addr),
+                                       sizeof(offset));
     *target_addr = offset;
     CPU::FlushICache(call_address(), kInstructionSize);
   }
 
   RawObject* ic_data() const {
     return *reinterpret_cast<RawObject**>(start_ + 1);
   }
 
   static const int kNumInstructions = 2;
   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_ + 1 * kInstructionSize;
   }
 
+ protected:
   uword start_;
+
+ private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(UnoptimizedCall);
 };
 
 
+class NativeCall : public UnoptimizedCall {
+ public:
+  explicit NativeCall(uword return_address) : UnoptimizedCall(return_address) {
+  }
+
+  NativeFunction native_function() const {
+    return *reinterpret_cast<NativeFunction*>(start_ + 1);
+  }
+
+  void set_native_function(NativeFunction func) const {
+    WritableInstructionsScope writable(start_ + 1, sizeof(func));
+    *reinterpret_cast<NativeFunction*>(start_ + 1) = func;
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(NativeCall);
+};
+
+
 class InstanceCall : public UnoptimizedCall {
  public:
   explicit InstanceCall(uword return_address)
       : UnoptimizedCall(return_address) {
 #if defined(DEBUG)
     ICData& test_ic_data = ICData::Handle();
     test_ic_data ^= ic_data();
     ASSERT(test_ic_data.NumArgsTested() > 0);
 #endif  // DEBUG
   }
@@ skipping 121 matching lines @@
   UnoptimizedStaticCall static_call(return_address);
   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);
 }
 
 
+void CodePatcher::PatchNativeCallAt(uword return_address,
+                                    const Code& code,
+                                    NativeFunction target,
+                                    const Code& trampoline) {
+  ASSERT(code.ContainsInstructionAt(return_address));
+  NativeCall call(return_address);
+  call.set_target(trampoline.EntryPoint());
+  call.set_native_function(target);
+}
+
+
+uword CodePatcher::GetNativeCallAt(uword return_address,
+                                   const Code& code,
+                                   NativeFunction* target) {
+  ASSERT(code.ContainsInstructionAt(return_address));
+  NativeCall call(return_address);
+  *target = call.native_function();
+  return call.target();
+}
+
+
+
 intptr_t CodePatcher::InstanceCallSizeInBytes() {
   return InstanceCall::kNumInstructions * InstanceCall::kInstructionSize;
 }
 
 
 // The expected code pattern of an edge counter in unoptimized code:
 //  b8 imm32    mov EAX, immediate
 class EdgeCounter : public ValueObject {
  public:
   EdgeCounter(uword pc, const Code& ignored)
@@ skipping 16 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_IA32