Recording array buffer views.

src/mark-compact.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 54 matching lines @@
       abort_incremental_marking_(false),
       marking_parity_(ODD_MARKING_PARITY),
       compacting_(false),
       was_marked_incrementally_(false),
       sweeping_pending_(false),
       sequential_sweeping_(false),
       tracer_(NULL),
       migration_slots_buffer_(NULL),
       heap_(NULL),
       code_flusher_(NULL),
-      encountered_weak_maps_(NULL) { }
+      encountered_weak_maps_(Smi::FromInt(0)),
+      encountered_array_buffers_(Smi::FromInt(0)) { }
 
 
 #ifdef VERIFY_HEAP
 class VerifyMarkingVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         CHECK(HEAP->mark_compact_collector()->IsMarked(object));
@@ skipping 300 matching lines @@
 
   return compacting_;
 }
 
 
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
   ASSERT(state_ == PREPARE_GC);
   ASSERT(encountered_weak_maps_ == Smi::FromInt(0));
+  ASSERT(encountered_array_buffers_ == Smi::FromInt(0));
 
   MarkLiveObjects();
   ASSERT(heap_->incremental_marking()->IsStopped());
 
   if (FLAG_collect_maps) ClearNonLiveReferences();
 
   ClearWeakMaps();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
@@ skipping 1872 matching lines @@
   string_table->IterateElements(&v);
   string_table->ElementsRemoved(v.PointersRemoved());
   heap()->external_string_table_.Iterate(&v);
   heap()->external_string_table_.CleanUp();
   heap()->error_object_list_.RemoveUnmarked(heap());
 
   // Process the weak references.
   MarkCompactWeakObjectRetainer mark_compact_object_retainer;
   heap()->ProcessWeakReferences(&mark_compact_object_retainer);
 
+  // Update references from array buffers to typed arrays.
+  ProcessArrayBuffers();
+
   // Remove object groups after marking phase.
   heap()->isolate()->global_handles()->RemoveObjectGroups();
   heap()->isolate()->global_handles()->RemoveImplicitRefGroups();
 
   // Flush code from collected candidates.
   if (is_code_flushing_enabled()) {
     code_flusher_->ProcessCandidates();
     // If incremental marker does not support code flushing, we need to
     // disable it before incremental marking steps for next cycle.
     if (FLAG_flush_code && !FLAG_flush_code_incrementally) {
@@ skipping 266 matching lines @@
         table->RemoveEntry(i);
       }
     }
     weak_map_obj = weak_map->next();
     weak_map->set_next(Smi::FromInt(0));
   }
   set_encountered_weak_maps(Smi::FromInt(0));
 }
 
 
+void MarkCompactCollector::ProcessArrayBuffers() {
+  Object* array_buffer_obj = encountered_array_buffers();
+  set_encountered_array_buffers(Smi::FromInt(0));
+  while (array_buffer_obj != Smi::FromInt(0)) {
+    ASSERT(IsMarked(HeapObject::cast(array_buffer_obj)));
+    JSArrayBuffer* array_buffer =
+      reinterpret_cast<JSArrayBuffer*>(array_buffer_obj);
+    Object** slot = HeapObject::RawField(array_buffer, JSArrayBuffer::kFirstArrayOffset);
+    while (*slot != Smi::FromInt(0)) {
+      Object* next_obj = *slot;
+      while (next_obj != Smi::FromInt(0) && !IsMarked(next_obj)) {
+        next_obj = JSTypedArray::cast(next_obj)->next();
+      }
+      if (next_obj == Smi::FromInt(0)) {
+        *slot = Smi::FromInt(0);
+        break;
+      }      
+      JSTypedArray* next_typed_array = JSTypedArray::cast(next_obj);
+      *slot = next_obj;
+      RecordSlot(slot, slot, next_typed_array);
+      slot = HeapObject::RawField(next_typed_array, JSTypedArray::kNextOffset);
+    }
+
+    array_buffer_obj = array_buffer->next();
+    array_buffer->set_next(Smi::FromInt(0));
+  }
+}
+
+
+void MarkCompactCollector::ClearArrayBuffersOnAbort() {
+  Object* array_buffer_obj = encountered_array_buffers();
+  set_encountered_array_buffers(Smi::FromInt(0));
+  while (array_buffer_obj != Smi::FromInt(0)) {
+    JSArrayBuffer* array_buffer = JSArrayBuffer::cast(array_buffer_obj);
+    array_buffer_obj = array_buffer->next();
+    array_buffer->set_next(Smi::FromInt(0));
+  }
+}
 // We scavange new space simultaneously with sweeping. This is done in two
 // passes.
 //
 // The first pass migrates all alive objects from one semispace to another or
 // promotes them to old space.  Forwarding address is written directly into
 // first word of object without any encoding.  If object is dead we write
 // NULL as a forwarding address.
 //
 // The second pass updates pointers to new space in all spaces.  It is possible
 // to encounter pointers to dead new space objects during traversal of pointers
@@ skipping 1659 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal