Correctly setup exit frame when calling into allocation tracker

src/x64/code-stubs-x64.cc

 // Copyright 2013 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 5799 matching lines @@
   Label fast_elements_case;
   __ cmpl(rcx, Immediate(FAST_ELEMENTS));
   __ j(equal, &fast_elements_case);
   GenerateCase(masm, FAST_HOLEY_ELEMENTS);
 
   __ bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
+void RecordObjectAllocationStub::Generate(MacroAssembler* masm) {
+  // ----------- S t a t e -------------
+  //  -- rsp[0]  : return address
+  //  -- rsp[8]  : new object address
+  //  -- rsp[16] : object size
+  // -----------------------------------
+  Isolate* isolate = masm->isolate();
+  FrameScope scope(masm, StackFrame::MANUAL);
+  __ EnterApiExitFrame(0);
+
+  __ PushSafepointRegisters();
+  __ PrepareCallCFunction(3);
+  __ movq(arg_reg_3, Operand(rbp,
+      kFPOnStackSize + kPCOnStackSize + 1 * kPointerSize));
+  __ movq(arg_reg_2, Operand(rbp, kFPOnStackSize + kPCOnStackSize));
+  __ movq(arg_reg_1, isolate, RelocInfo::EXTERNAL_REFERENCE);

[Yang, 2013/10/30 15:12:57]

If you need to erect a frame and also pass the isolate, why don't you simply
call into a runtime function using CallRuntime? That uses the CEntryStub and
takes care of the isolate.

[yurys, 2013/10/31 08:56:01]

There are two reasons for this:
1. CallRuntime doesn't preserve registers. Since we call HeapProfiler in the
middle of allocation we should be careful not to change current state of the
instrumented code.
2. Does a lot of checks related to GC which are unnecessary in our case since
the allocation hook is guaranteed not to do any heap allocations. As long as
we'd like to minimize perf impact of the allocation tracker we'd rather avoid
unnecessary checks.

+  __ CallCFunction(
+      ExternalReference::record_object_allocation_function(isolate), 3);
+  __ PopSafepointRegisters();
+
+  __ LeaveApiExitFrame(false);
+  __ ret(0);
+}
+
+
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64