Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1548)

Unified Diff: runtime/vm/code_patcher_x64.cc

Issue 8984003: Port code generator to x64. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/
Patch Set: '' Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/code_index_table_test.cc ('k') | runtime/vm/code_patcher_x64_test.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/code_patcher_x64.cc
===================================================================
--- runtime/vm/code_patcher_x64.cc (revision 2556)
+++ runtime/vm/code_patcher_x64.cc (working copy)
@@ -5,69 +5,253 @@
#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"
+#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:
+// 00: 48 bb imm64 mov RBX, immediate 1
+// 10: 49 ba imm64 mov R10, immediate 2
+// 20: 49 bb imm64 mov R11, target_address
+// 30: 41 ff d3 call R11
+// 33: <- return_address
+class DartCallPattern : public ValueObject {
+ public:
+ explicit DartCallPattern(uword return_address)
+ : start_(return_address - kCallPatternSize) {
+ ASSERT(IsValid(return_address));
+ ASSERT((kCallPatternSize - 20) == Assembler::kCallExternalLabelSize);
+ }
+
+ static const int kCallPatternSize = 33;
+
+ static bool IsValid(uword return_address) {
+ uint8_t* code_bytes =
+ reinterpret_cast<uint8_t*>(return_address - kCallPatternSize);
+ return (code_bytes[00] == 0x48) && (code_bytes[01] == 0xBB) &&
+ (code_bytes[10] == 0x49) && (code_bytes[11] == 0xBA) &&
+ (code_bytes[20] == 0x49) && (code_bytes[21] == 0xBB) &&
+ (code_bytes[30] == 0x41) && (code_bytes[31] == 0xFF) &&
+ (code_bytes[32] == 0xD3);
+ }
+
+ uword target() const {
+ return *reinterpret_cast<uword*>(start_ + 20 + 2);
+ }
+
+ void set_target(uword target) const {
+ uword* target_addr = reinterpret_cast<uword*>(start_ + 20 + 2);
+ *target_addr = target;
+ CPU::FlushICache(start_ + 20, 2 + 8);
+ }
+
+ uint64_t immediate_one() const {
+ return *reinterpret_cast<uint64_t*>(start_ + 0 + 2);
+ }
+
+ void set_immediate_one(uint64_t value) {
+ uint64_t* target_addr = reinterpret_cast<uint64_t*>(start_ + 0 + 2);
+ *target_addr = value;
+ CPU::FlushICache(start_ + 0, 2 + 8);
+ }
+
+ uint64_t immediate_two() const {
+ return *reinterpret_cast<uint64_t*>(start_ + 10 + 2);
+ }
+
+ 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();
+ }
+
+ uword start_;
+ DISALLOW_IMPLICIT_CONSTRUCTORS(DartCallPattern);
+};
+
+
+// A Dart static call passes the function object in RBX.
+class StaticCall : public DartCallPattern {
+ public:
+ explicit StaticCall(uword return_address)
+ : DartCallPattern(return_address) {}
+
+ RawFunction* function() const {
+ Function& f = Function::Handle();
+ f ^= reinterpret_cast<RawObject*>(immediate_one());
+ return f.raw();
+ }
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(StaticCall);
+};
+
+
+// A Dart instance call passes the ic-data array in RBX.
+class InstanceCall : public DartCallPattern {
+ 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<int64_t>(value.raw()));
+ }
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceCall);
+};
+
+
void CodePatcher::GetStaticCallAt(uword return_address,
Function* function,
uword* target) {
- UNIMPLEMENTED();
+ ASSERT(function != NULL);
+ ASSERT(target != NULL);
+ StaticCall call(return_address);
+ *target = call.target();
+ *function = call.function();
}
void CodePatcher::PatchStaticCallAt(uword return_address, uword new_target) {
- UNIMPLEMENTED();
+ StaticCall call(return_address);
+ call.set_target(new_target);
}
void CodePatcher::PatchInstanceCallAt(uword return_address, uword new_target) {
- UNIMPLEMENTED();
+ InstanceCall call(return_address);
+ call.set_target(new_target);
}
-bool CodePatcher::IsDartCall(uword return_address) {
- UNIMPLEMENTED();
- return false;
+static void SwapCode(intptr_t num_bytes, char* a, char* b) {
+ for (intptr_t i = 0; i < num_bytes; i++) {
+ char tmp = *a;
+ *a = *b;
+ *b = tmp;
+ a++;
+ b++;
+ }
}
-void CodePatcher::GetInstanceCallAt(uword return_address,
- String* function_name,
- int* num_arguments,
- int* num_named_arguments,
- uword* target) {
- UNIMPLEMENTED();
-}
-
-
+// The patch code buffer contains the jump code sequence which will be inserted
+// at entry point.
void CodePatcher::PatchEntry(const Code& code) {
- UNIMPLEMENTED();
+ Jump jmp_entry(code.EntryPoint());
+ ASSERT(!jmp_entry.IsValid());
+ const uword patch_buffer = code.GetPatchCodePc();
+ ASSERT(patch_buffer != 0);
+ Jump jmp_patch(patch_buffer);
+ ASSERT(jmp_patch.IsValid());
+ const uword jump_target = jmp_patch.TargetAddress();
+ SwapCode(jmp_patch.pattern_length_in_bytes(),
+ reinterpret_cast<char*>(code.EntryPoint()),
+ reinterpret_cast<char*>(patch_buffer));
+ jmp_entry.SetTargetAddress(jump_target);
}
+// The entry point is a jump code sequence, the patch code buffer contains
+// original code, the entry point contains the jump code sequence.
void CodePatcher::RestoreEntry(const Code& code) {
- UNIMPLEMENTED();
+ Jump jmp_entry(code.EntryPoint());
+ ASSERT(jmp_entry.IsValid());
+ const uword jump_target = jmp_entry.TargetAddress();
+ const uword patch_buffer = code.GetPatchCodePc();
+ ASSERT(patch_buffer != 0);
+ // 'patch_buffer' contains original entry code.
+ Jump jmp_patch(patch_buffer);
+ ASSERT(!jmp_patch.IsValid());
+ SwapCode(jmp_patch.pattern_length_in_bytes(),
+ reinterpret_cast<char*>(code.EntryPoint()),
+ reinterpret_cast<char*>(patch_buffer));
+ ASSERT(jmp_patch.IsValid());
+ jmp_patch.SetTargetAddress(jump_target);
}
bool CodePatcher::CodeIsPatchable(const Code& code) {
- UNIMPLEMENTED();
- return false;
+ Jump jmp_entry(code.EntryPoint());
+ if (code.Size() < (jmp_entry.pattern_length_in_bytes() * 2)) {
+ return false;
+ }
+ uword limit = code.EntryPoint() + jmp_entry.pattern_length_in_bytes();
+ for (intptr_t i = 0; i < code.pointer_offsets_length(); i++) {
+ const uword addr = code.GetPointerOffsetAt(i) + code.EntryPoint();
+ if (addr < limit) {
+ return false;
+ }
+ }
+ return true;
}
+bool CodePatcher::IsDartCall(uword return_address) {
+ return DartCallPattern::IsValid(return_address);
+}
+
+
+void CodePatcher::GetInstanceCallAt(uword return_address,
+ String* function_name,
+ int* num_arguments,
+ int* num_named_arguments,
+ uword* target) {
+ ASSERT(function_name != NULL);
+ ASSERT(num_arguments != NULL);
+ ASSERT(num_named_arguments != NULL);
+ ASSERT(target != NULL);
+ InstanceCall call(return_address);
+ *num_arguments = call.argument_count();
+ *num_named_arguments = call.named_argument_count();
+ *target = call.target();
+ ICData ic_data(Array::ZoneHandle(call.ic_data()));
+ *function_name = ic_data.FunctionName();
+}
+
+
RawArray* CodePatcher::GetInstanceCallIcDataAt(uword return_address) {
- UNIMPLEMENTED();
- return NULL;
+ InstanceCall call(return_address);
+ return call.ic_data();
}
void CodePatcher::SetInstanceCallIcDataAt(uword return_address,
- const Array& ic_data) {
- UNIMPLEMENTED();
+ const Array& ic_data) {
+ InstanceCall call(return_address);
+ call.SetIcData(ic_data);
}
+
+intptr_t CodePatcher::InstanceCallSizeInBytes() {
+ return DartCallPattern::kCallPatternSize;
+}
+
} // namespace dart
#endif // defined TARGET_ARCH_X64
« no previous file with comments | « runtime/vm/code_index_table_test.cc ('k') | runtime/vm/code_patcher_x64_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698