X64: Implement debugger hooks.

src/x64/macro-assembler-x64.cc

 // 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 244 matching lines @@
        reinterpret_cast<intptr_t>(Smi::FromInt(p1 - p0)),
        RelocInfo::NONE);
   push(kScratchRegister);
   CallRuntime(Runtime::kAbort, 2);
   // will not return here
 }
 
 
 void MacroAssembler::CallStub(CodeStub* stub) {
   ASSERT(allow_stub_calls());  // calls are not allowed in some stubs
-  movq(kScratchRegister, stub->GetCode(), RelocInfo::CODE_TARGET);
-  call(kScratchRegister);
+  Call(stub->GetCode(), RelocInfo::CODE_TARGET);
 }
 
 
 void MacroAssembler::StubReturn(int argc) {
   ASSERT(argc >= 1 && generating_stub());
   ret((argc - 1) * kPointerSize);
 }
 
 
 void MacroAssembler::IllegalOperation(int num_arguments) {
@@ skipping 211 matching lines @@
 }
 
 
 void MacroAssembler::Jump(Address destination, RelocInfo::Mode rmode) {
   movq(kScratchRegister, destination, rmode);
   jmp(kScratchRegister);
 }
 
 
 void MacroAssembler::Jump(Handle<Code> code_object, RelocInfo::Mode rmode) {
-  WriteRecordedPositions();

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

How can it be correct to remove this?

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

It's correct in the sense that it matches what we do in ia32.
We only record positions where we can set breakpoints, and we can only set
breakpoints at stub calls and JSReturn sequences. In ia32 that means
call(Handle<...>) and at function return.

   ASSERT(RelocInfo::IsCodeTarget(rmode));
   movq(kScratchRegister, code_object, rmode);
 #ifdef DEBUG
   Label target;
   bind(&target);
 #endif
   jmp(kScratchRegister);
 #ifdef DEBUG
   ASSERT_EQ(kTargetAddrToReturnAddrDist,
             SizeOfCodeGeneratedSince(&target) + kPointerSize);
 #endif
 }
 
 
 void MacroAssembler::Call(ExternalReference ext) {
   movq(kScratchRegister, ext);
   call(kScratchRegister);
 }
 
 
 void MacroAssembler::Call(Address destination, RelocInfo::Mode rmode) {
   movq(kScratchRegister, destination, rmode);
   call(kScratchRegister);
 }
 
 
 void MacroAssembler::Call(Handle<Code> code_object, RelocInfo::Mode rmode) {
+  ASSERT(RelocInfo::IsCodeTarget(rmode));
   WriteRecordedPositions();
-  ASSERT(RelocInfo::IsCodeTarget(rmode));
   movq(kScratchRegister, code_object, rmode);
 #ifdef DEBUG
   // Patch target is kPointer size bytes *before* target label.
   Label target;
   bind(&target);
 #endif
   call(kScratchRegister);
 #ifdef DEBUG
   ASSERT_EQ(kTargetAddrToReturnAddrDist,
             SizeOfCodeGeneratedSince(&target) + kPointerSize);
@@ skipping 314 matching lines @@
   if (!definitely_matches) {
     Handle<Code> adaptor =
         Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline));
     if (!code_constant.is_null()) {
       movq(rdx, code_constant, RelocInfo::EMBEDDED_OBJECT);
       addq(rdx, Immediate(Code::kHeaderSize - kHeapObjectTag));
     } else if (!code_register.is(rdx)) {
       movq(rdx, code_register);
     }
 
-    movq(kScratchRegister, adaptor, RelocInfo::CODE_TARGET);
     if (flag == CALL_FUNCTION) {
-      call(kScratchRegister);
+      Call(adaptor, RelocInfo::CODE_TARGET);
       jmp(done);
     } else {
-      jmp(kScratchRegister);
+      Jump(adaptor, RelocInfo::CODE_TARGET);
     }
     bind(&invoke);
   }
 }
 
 
 void MacroAssembler::InvokeCode(Register code,
                                 const ParameterCount& expected,
                                 const ParameterCount& actual,
                                 InvokeFlag flag) {
@@ skipping 320 matching lines @@
                      Context::SECURITY_TOKEN_INDEX * kPointerSize;
   movq(scratch, FieldOperand(scratch, token_offset));
   cmpq(scratch, FieldOperand(kScratchRegister, token_offset));
   j(not_equal, miss);
 
   bind(&same_contexts);
 }
 
 
 } }  // namespace v8::internal