Add statistics operations and long calls and jumps to x64 macro assembler.

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 102 matching lines @@
     movq(kScratchRegister, Immediate(x));
   } else if (is_uint32(x)) {
     movl(kScratchRegister, Immediate(x));
   } else {
     movq(kScratchRegister, x, RelocInfo::NONE);
   }
   movq(dst, kScratchRegister);
 }
 
 
+void MacroAssembler::Jump(ExternalReference ext) {
+  movq(kScratchRegister, ext);
+  jmp(kScratchRegister);
+}
+
+
+void MacroAssembler::Jump(Address destination, RelocInfo::Mode rmode) {
+  movq(kScratchRegister, destination, rmode);
+  jmp(kScratchRegister);
+}
+
+
+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::PushTryHandler(CodeLocation try_location,
                                     HandlerType type) {
   // Adjust this code if not the case.
   ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize);
 
   // The pc (return address) is already on TOS.  This code pushes state,
   // frame pointer and current handler.  Check that they are expected
   // next on the stack, in that order.
   ASSERT_EQ(StackHandlerConstants::kStateOffset,
             StackHandlerConstants::kPCOffset - kPointerSize);
@@ skipping 18 matching lines @@
     push(Immediate(0));  // NULL frame pointer.
   }
   // Save the current handler.
   movq(kScratchRegister, ExternalReference(Top::k_handler_address));
   push(Operand(kScratchRegister, 0));
   // Link this handler.
   movq(Operand(kScratchRegister, 0), rsp);
 }
 
 
+void MacroAssembler::Ret() {
+  ret(0);
+}
+
+
+void MacroAssembler::SetCounter(StatsCounter* counter, int value) {
+  if (FLAG_native_code_counters && counter->Enabled()) {
+    movq(kScratchRegister, ExternalReference(counter));
+    movl(Operand(kScratchRegister, 0), Immediate(value));
+  }
+}
+
+
+void MacroAssembler::IncrementCounter(StatsCounter* counter, int value) {
+  ASSERT(value > 0);
+  if (FLAG_native_code_counters && counter->Enabled()) {
+    movq(kScratchRegister, ExternalReference(counter));
+    Operand operand(kScratchRegister, 0);
+    if (value == 1) {
+      incl(operand);
+    } else {
+      addl(operand, Immediate(value));
+    }
+  }
+}
+
+
+void MacroAssembler::DecrementCounter(StatsCounter* counter, int value) {
+  ASSERT(value > 0);
+  if (FLAG_native_code_counters && counter->Enabled()) {
+    movq(kScratchRegister, ExternalReference(counter));
+    Operand operand(kScratchRegister, 0);
+    if (value == 1) {
+      decl(operand);
+    } else {
+      subl(operand, Immediate(value));
+    }
+  }
+}
+
+
 #ifdef ENABLE_DEBUGGER_SUPPORT
 
 void MacroAssembler::PushRegistersFromMemory(RegList regs) {
   ASSERT((regs & ~kJSCallerSaved) == 0);
   // Push the content of the memory location to the stack.
   for (int i = 0; i < kNumJSCallerSaved; i++) {
     int r = JSCallerSavedCode(i);
     if ((regs & (1 << r)) != 0) {
       ExternalReference reg_addr =
           ExternalReference(Debug_Address::Register(i));
@@ skipping 87 matching lines @@
   push(rbp);
   movq(rbp, rsp);
   push(rsi);  // Context.
   push(Immediate(Smi::FromInt(type)));
   movq(kScratchRegister, CodeObject(), RelocInfo::EMBEDDED_OBJECT);
   push(kScratchRegister);
   if (FLAG_debug_code) {
     movq(kScratchRegister,
          Factory::undefined_value(),
          RelocInfo::EMBEDDED_OBJECT);
-    cmp(Operand(rsp, 0), kScratchRegister);
+    cmpq(Operand(rsp, 0), kScratchRegister);
     Check(not_equal, "code object not properly patched");
   }
 }
 
 
 void MacroAssembler::LeaveFrame(StackFrame::Type type) {
   if (FLAG_debug_code) {
     movq(kScratchRegister, Immediate(Smi::FromInt(type)));
-    cmp(Operand(rbp, StandardFrameConstants::kMarkerOffset), kScratchRegister);
+    cmpq(Operand(rbp, StandardFrameConstants::kMarkerOffset), kScratchRegister);
     Check(equal, "stack frame types must match");
   }
   movq(rsp, rbp);
   pop(rbp);
 }
 
 
 
 void MacroAssembler::EnterExitFrame(StackFrame::Type type) {
   ASSERT(type == StackFrame::EXIT || type == StackFrame::EXIT_DEBUG);
@@ skipping 33 matching lines @@
     // CopyRegistersFromStackToMemory() but it isn't! esp is assumed
     // correct here, but computed for the other call. Very error
     // prone! FIX THIS.  Actually there are deeper problems with
     // register saving than this asymmetry (see the bug report
     // associated with this issue).
     PushRegistersFromMemory(kJSCallerSaved);
   }
 #endif
 
   // Reserve space for two arguments: argc and argv.
-  sub(rsp, Immediate(2 * kPointerSize));
+  subq(rsp, Immediate(2 * kPointerSize));
 
   // Get the required frame alignment for the OS.
   static const int kFrameAlignment = OS::ActivationFrameAlignment();
   if (kFrameAlignment > 0) {
     ASSERT(IsPowerOf2(kFrameAlignment));
     movq(r10, Immediate(-kFrameAlignment));
     and_(rsp, r10);
   }
 
   // Patch the saved entry sp.
@@ skipping 34 matching lines @@
   push(rcx);
 
   // Clear the top frame.
   ExternalReference c_entry_fp_address(Top::k_c_entry_fp_address);
   movq(kScratchRegister, c_entry_fp_address);
   movq(Operand(kScratchRegister, 0), Immediate(0));
 }
 
 
 } }  // namespace v8::internal