X64: Implement debugger hooks.

src/x64/assembler-x64-inl.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 210 matching lines @@
 }
 
 
 void RelocInfo::set_target_object(Object* target) {
   ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
   *reinterpret_cast<Object**>(pc_) = target;
 }
 
 
 bool RelocInfo::IsCallInstruction() {
-  UNIMPLEMENTED();  // IA32 code below.
-  return *pc_ == 0xE8;
+  // TODO(X64) If allowing short (relative32 offset) jumps, also
+  // recognize 0xE8!
+  return pc_[11] != 0xCC;

[Søren Thygesen Gjesse, 2009/08/18 13:10:44]

Please explain why non int3 instruction at pc + 11 is a call instruction :-).

[Lasse Reichstein, 2009/08/19 07:07:55]

Has been elaborated.
We only need to distinguish a call sequence from a JS return sequence, and only
the latter has int3 at that position.

 }
 
 
 Address RelocInfo::call_address() {
-  UNIMPLEMENTED();  // IA32 code below.
   ASSERT(IsCallInstruction());
-  return Assembler::target_address_at(pc_ + 1);
+  return
+      Assembler::target_address_at(pc_ + Assembler::kReturnAddrPatchPrefixSize);
 }
 
 
 void RelocInfo::set_call_address(Address target) {
-  UNIMPLEMENTED();  // IA32 code below.
   ASSERT(IsCallInstruction());
-  Assembler::set_target_address_at(pc_ + 1, target);
+  Assembler::set_target_address_at(pc_ + Assembler::kReturnAddrPatchPrefixSize,

[William Hesse, 2009/08/19 08:44:00]

I really think this name is bad.  Maybe there should be a friend Patcher class,
and this could be Patcher::ReturnSequenceAddressOffset.
Patcher::ReturnSequenceSize,
and so on.

[Lasse Reichstein, 2009/08/19 10:12:32]

I can't see a good and quick way to separate it. I have renamed the constants to
kPatchReturnSequenceAddressOffset and kPatchReturnSequenceLength. We should
think about a prettier solution.

+                                   target);
 }
 
 
 Object* RelocInfo::call_object() {
-  UNIMPLEMENTED();  // IA32 code below.
   ASSERT(IsCallInstruction());
   return *call_object_address();
 }
 
 
 void RelocInfo::set_call_object(Object* target) {
-  UNIMPLEMENTED();  // IA32 code below.
   ASSERT(IsCallInstruction());
   *call_object_address() = target;
 }
 
 
 Object** RelocInfo::call_object_address() {
-  UNIMPLEMENTED();  // IA32 code below.
   ASSERT(IsCallInstruction());
-  return reinterpret_cast<Object**>(pc_ + 1);
+  return
+      reinterpret_cast<Object**>(pc_ + Assembler::kReturnAddrPatchPrefixSize);
 }
 
 // -----------------------------------------------------------------------------
 // Implementation of Operand
 
 void Operand::set_modrm(int mod, Register rm_reg) {
   ASSERT(is_uint2(mod));
   buf_[0] = mod << 6 | rm_reg.low_bits();
   // Set REX.B to the high bit of rm.code().
   rex_ |= rm_reg.high_bit();
@@ skipping 23 matching lines @@
   ASSERT(len_ == 1 || len_ == 2);
   int32_t* p = reinterpret_cast<int32_t*>(&buf_[len_]);
   *p = disp;
   len_ += sizeof(int32_t);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_ASSEMBLER_X64_INL_H_