Hook-allocation on bleeding edge

src/spaces-inl.h

 // Copyright 2011 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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_SPACES_INL_H_
 #define V8_SPACES_INL_H_
 
 #include "isolate.h"
+#include "heap-profiler.h"
 #include "spaces.h"
 #include "v8memory.h"
 
 namespace v8 {
 namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // Bitmap
 
@@ skipping 224 matching lines @@
   Address current_top = allocation_info_.top;
   Address new_top = current_top + size_in_bytes;
   if (new_top > allocation_info_.limit) return NULL;
 
   allocation_info_.top = new_top;
   return HeapObject::FromAddress(current_top);
 }
 
 
 // Raw allocation.
-MaybeObject* PagedSpace::AllocateRaw(int size_in_bytes) {
+HeapObject* PagedSpace::AllocateRawHelper(int size_in_bytes) {
   HeapObject* object = AllocateLinearly(size_in_bytes);
   if (object != NULL) {
     if (identity() == CODE_SPACE) {
       SkipList::Update(object->address(), size_in_bytes);
     }
     return object;
   }
 
   ASSERT(!heap()->linear_allocation() ||
          (anchor_.next_chunk() == &anchor_ &&
           anchor_.prev_chunk() == &anchor_));
 
   object = free_list_.Allocate(size_in_bytes);
   if (object != NULL) {
     if (identity() == CODE_SPACE) {
       SkipList::Update(object->address(), size_in_bytes);
     }
     return object;
   }
 
   object = SlowAllocateRaw(size_in_bytes);
   if (object != NULL) {
     if (identity() == CODE_SPACE) {
       SkipList::Update(object->address(), size_in_bytes);
     }
     return object;
   }
 
+  return NULL;
+}
+
+
+MaybeObject* PagedSpace::AllocateRaw(int size_in_bytes) {
+  HeapObject* object = AllocateRawHelper(size_in_bytes);
+  if (object != NULL) {
+    heap()->isolate()->heap_profiler()->RecordObjectAllocation(
+      object->address(), size_in_bytes);
+    return object;
+  }
   return Failure::RetryAfterGC(identity());
 }
 
+
+MaybeObject* PagedSpace::AllocateRawSilently(int size_in_bytes) {
+  HeapObject* object = AllocateRawHelper(size_in_bytes);
+  if (object != NULL) {
+    return object;
+  }
+  return Failure::RetryAfterGC(identity());
+}
+
 
 // -----------------------------------------------------------------------------
 // NewSpace
 
 
 MaybeObject* NewSpace::AllocateRaw(int size_in_bytes) {
   Address old_top = allocation_info_.top;
 #ifdef DEBUG
   // If we are stressing compaction we waste some memory in new space
   // in order to get more frequent GCs.
   if (FLAG_stress_compaction && !HEAP->linear_allocation()) {
     if (allocation_info_.limit - old_top >= size_in_bytes * 4) {
       int filler_size = size_in_bytes * 4;
       for (int i = 0; i < filler_size; i += kPointerSize) {
         *(reinterpret_cast<Object**>(old_top + i)) =
             HEAP->one_pointer_filler_map();
       }
       old_top += filler_size;
       allocation_info_.top += filler_size;
     }
   }
 #endif
 
   if (allocation_info_.limit - old_top < size_in_bytes) {
     return SlowAllocateRaw(size_in_bytes);
   }
 
-  Object* obj = HeapObject::FromAddress(old_top);
+  HeapObject* obj = HeapObject::FromAddress(old_top);
   allocation_info_.top += size_in_bytes;
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
+  heap()->isolate()->heap_profiler()->RecordObjectAllocation(
+    obj->address(), size_in_bytes);
+
   return obj;
 }
 
 
 LargePage* LargePage::Initialize(Heap* heap, MemoryChunk* chunk) {
   heap->incremental_marking()->SetOldSpacePageFlags(chunk);
   return static_cast<LargePage*>(chunk);
 }
 
 
 intptr_t LargeObjectSpace::Available() {
   return ObjectSizeFor(heap()->isolate()->memory_allocator()->Available());
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   Map* map = object->map();
   Heap* heap = object->GetHeap();
   return map == heap->raw_unchecked_free_space_map()
       || map == heap->raw_unchecked_one_pointer_filler_map()
       || map == heap->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_