Hook-allocation on bleeding edge

src/x64/macro-assembler-x64.cc

 // Copyright 2012 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 3877 matching lines @@
     if (tag_result) {
       subq(result, Immediate(object_size - kHeapObjectTag));
     } else {
       subq(result, Immediate(object_size));
     }
   } else if (tag_result) {
     // Tag the result if requested.
     ASSERT(kHeapObjectTag == 1);
     incq(result);
   }
+
+  RecordObjectAllocation(isolate(), result, object_size);
 }
 
 
 void MacroAssembler::Allocate(int header_size,
                               ScaleFactor element_size,
                               Register element_count,
                               Register result,
                               Register result_end,
                               Register scratch,
                               Label* gc_required,
@@ skipping 48 matching lines @@
   cmpq(result_end, limit_operand);
   j(above, gc_required);
 
   // Update allocation top.
   UpdateAllocationTopHelper(result_end, scratch, flags);
 
   // Tag the result if requested.
   if ((flags & TAG_OBJECT) != 0) {
     addq(result, Immediate(kHeapObjectTag));
   }
+
+  RecordObjectAllocation(isolate(), result, object_size);
 }
 
 
 void MacroAssembler::UndoAllocationInNewSpace(Register object) {
   ExternalReference new_space_allocation_top =
       ExternalReference::new_space_allocation_top_address(isolate());
 
   // Make sure the object has no tag before resetting top.
   and_(object, Immediate(~kHeapObjectTagMask));
   Operand top_operand = ExternalOperand(new_space_allocation_top);
@@ skipping 715 matching lines @@
   cmpq(scratch_reg, kScratchRegister);
   j(less, &no_memento_available);
   cmpq(scratch_reg, ExternalOperand(new_space_allocation_top));
   j(greater, &no_memento_available);
   CompareRoot(MemOperand(scratch_reg, -AllocationMemento::kSize),
               Heap::kAllocationMementoMapRootIndex);
   bind(&no_memento_available);
 }
 
 
+void MacroAssembler::RecordObjectAllocation(Isolate* isolate,
+                                            Register object,
+                                            Register object_size) {
+  Label done;
+  cmpl(ExternalOperand(
+         ExternalReference::is_tracking_allocations_address(isolate)),
+       Immediate(0));
+  j(zero, &done, Label::kNear);
+  FrameScope frame(this, StackFrame::MANUAL);
+  PushSafepointRegisters();
+  PrepareCallCFunction(3);
+  // In case object is rdx
+  movq(kScratchRegister, object);
+  movq(rdx, object_size);
+  movq(rsi, kScratchRegister);
+  movq(rdi, isolate, RelocInfo::EXTERNAL_REFERENCE);
+  CallCFunction(
+    ExternalReference::record_object_allocation_function(isolate), 3);
+  PopSafepointRegisters();
+  bind(&done);
+}
+
+
+void MacroAssembler::RecordObjectAllocation(Isolate* isolate,
+                                            Register object,
+                                            int object_size) {
+  Label done;
+  cmpl(ExternalOperand(
+         ExternalReference::is_tracking_allocations_address(isolate)),
+       Immediate(0));
+  j(zero, &done, Label::kNear);
+  FrameScope frame(this, StackFrame::MANUAL);
+  PushSafepointRegisters();
+  PrepareCallCFunction(3);
+  movq(rsi, object);
+  movq(rdx, Immediate(object_size));
+  movq(rdi, isolate, RelocInfo::EXTERNAL_REFERENCE);
+  CallCFunction(
+    ExternalReference::record_object_allocation_function(isolate), 3);
+  PopSafepointRegisters();
+  bind(&done);
+}
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64