Factor out common code from platform-specific deoptimization. Fix Deoptimizer not to need to partit…

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 55 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_collections_(NULL) { }
-
+      encountered_weak_collections_(NULL),
+      code_to_deoptimize_(NULL) { }
 
 #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 397 matching lines @@
 }
 
 
 void MarkCompactCollector::VerifyWeakEmbeddedMapsInOptimizedCode() {
   HeapObjectIterator code_iterator(heap()->code_space());
   for (HeapObject* obj = code_iterator.Next();
        obj != NULL;
        obj = code_iterator.Next()) {
     Code* code = Code::cast(obj);
     if (code->kind() != Code::OPTIMIZED_FUNCTION) continue;
-    if (code->marked_for_deoptimization()) continue;
+    if (WillBeDeoptimized(code)) continue;
     code->VerifyEmbeddedMapsDependency();
   }
 }
 
 
 void MarkCompactCollector::VerifyOmittedPrototypeChecks() {
   HeapObjectIterator iterator(heap()->map_space());
   for (HeapObject* obj = iterator.Next();
        obj != NULL;
        obj = iterator.Next()) {
@@ skipping 432 matching lines @@
   }
 
 #ifdef VERIFY_HEAP
   if (!was_marked_incrementally_ && FLAG_verify_heap) {
     VerifyMarkbitsAreClean();
   }
 #endif
 }
 
 
-class DeoptimizeMarkedCodeFilter : public OptimizedFunctionFilter {
- public:
-  virtual bool TakeFunction(JSFunction* function) {
-    return function->code()->marked_for_deoptimization();
-  }
-};
-
-
 void MarkCompactCollector::Finish() {
 #ifdef DEBUG
   ASSERT(state_ == SWEEP_SPACES || state_ == RELOCATE_OBJECTS);
   state_ = IDLE;
 #endif
   // The stub cache is not traversed during GC; clear the cache to
   // force lazy re-initialization of it. This must be done after the
   // GC, because it relies on the new address of certain old space
   // objects (empty string, illegal builtin).
   isolate()->stub_cache()->Clear();
 
-  DeoptimizeMarkedCodeFilter filter;
-  Deoptimizer::DeoptimizeAllFunctionsWith(isolate(), &filter);
+  if (code_to_deoptimize_ != Smi::FromInt(0)) {
+    // Convert the linked list of Code objects into a ZoneList.
+    Zone zone(isolate());
+    ZoneList<Code*> codes(4, &zone);
+
+    Object *list = code_to_deoptimize_;
+    while (list->IsCode()) {
+      Code *code = Code::cast(list);
+      list = code->code_to_deoptimize_link();
+      codes.Add(code, &zone);
+      // Destroy the link and don't ever try to deoptimize this code again.
+      code->set_code_to_deoptimize_link(Smi::FromInt(0));
+    }
+    code_to_deoptimize_ = Smi::FromInt(0);
+
+    Deoptimizer::DeoptimizeCodeList(isolate(), &codes);
+  }
 }
 
 
 // -------------------------------------------------------------------------
 // Phase 1: tracing and marking live objects.
 //   before: all objects are in normal state.
 //   after: a live object's map pointer is marked as '00'.
 
 // Marking all live objects in the heap as part of mark-sweep or mark-compact
 // collection.  Before marking, all objects are in their normal state.  After
@@ skipping 1624 matching lines @@
   DisallowHeapAllocation no_allocation;
   DependentCode* entries = map->dependent_code();
   DependentCode::GroupStartIndexes starts(entries);
   int number_of_entries = starts.number_of_entries();
   if (number_of_entries == 0) return;
   for (int i = 0; i < number_of_entries; i++) {
     // If the entry is compilation info then the map must be alive,
     // and ClearAndDeoptimizeDependentCode shouldn't be called.
     ASSERT(entries->is_code_at(i));
     Code* code = entries->code_at(i);
-    if (IsMarked(code) && !code->marked_for_deoptimization()) {
-      code->set_marked_for_deoptimization(true);
+
+    if (IsMarked(code) && !WillBeDeoptimized(code)) {
+      // Insert the code into the code_to_deoptimize linked list.
+      Object* next = code_to_deoptimize_;
+      if (next != Smi::FromInt(0)) {
+        // Record the slot so that it is updated.
+        Object** slot = code->code_to_deoptimize_link_slot();
+        RecordSlot(slot, slot, next);
+      }
+      code->set_code_to_deoptimize_link(next);
+      code_to_deoptimize_ = code;
     }
     entries->clear_at(i);
   }
   map->set_dependent_code(DependentCode::cast(heap()->empty_fixed_array()));
 }
 
 
 void MarkCompactCollector::ClearNonLiveDependentCode(DependentCode* entries) {
   DisallowHeapAllocation no_allocation;
   DependentCode::GroupStartIndexes starts(entries);
   int number_of_entries = starts.number_of_entries();
   if (number_of_entries == 0) return;
   int new_number_of_entries = 0;
   // Go through all groups, remove dead codes and compact.
   for (int g = 0; g < DependentCode::kGroupCount; g++) {
     int group_number_of_entries = 0;
     for (int i = starts.at(g); i < starts.at(g + 1); i++) {
       Object* obj = entries->object_at(i);
       ASSERT(obj->IsCode() || IsMarked(obj));
       if (IsMarked(obj) &&
-          (!obj->IsCode() || !Code::cast(obj)->marked_for_deoptimization())) {
+          (!obj->IsCode() || !WillBeDeoptimized(Code::cast(obj)))) {
         if (new_number_of_entries + group_number_of_entries != i) {
           entries->set_object_at(
               new_number_of_entries + group_number_of_entries, obj);
         }
         Object** slot = entries->slot_at(new_number_of_entries +
                                          group_number_of_entries);
         RecordSlot(slot, slot, obj);
         group_number_of_entries++;
       }
     }
@@ skipping 617 matching lines @@
 
     // If the object is white than no slots were recorded on it yet.
     MarkBit mark_bit = Marking::MarkBitFrom(code);
     if (Marking::IsWhite(mark_bit)) return;
 
     invalidated_code_.Add(code);
   }
 }
 
 
+// Return true if the given code is deoptimized or will be deoptimized.
+bool MarkCompactCollector::WillBeDeoptimized(Code* code) {
+  // We assume the code_to_deoptimize_link is initialized to undefined.
+  // If it is 0, or refers to another Code object, then this code
+  // is already linked, or was already linked into the list.
+  return code->code_to_deoptimize_link() != heap()->undefined_value()
+      || code->marked_for_deoptimization();
+}
+
+
 bool MarkCompactCollector::MarkInvalidatedCode() {
   bool code_marked = false;
 
   int length = invalidated_code_.length();
   for (int i = 0; i < length; i++) {
     Code* code = invalidated_code_[i];
 
     if (SetMarkBitsUnderInvalidatedCode(code, true)) {
       code_marked = true;
     }
@@ skipping 163 matching lines @@
   HeapObjectIterator js_global_property_cell_iterator(
       heap_->property_cell_space());
   for (HeapObject* cell = js_global_property_cell_iterator.Next();
        cell != NULL;
        cell = js_global_property_cell_iterator.Next()) {
     if (cell->IsPropertyCell()) {
       PropertyCell::BodyDescriptor::IterateBody(cell, &updating_visitor);
     }
   }
 
-  // Update pointer from the native contexts list.
+  // Update the heads of the native contexts list the code to deoptimize list.
   updating_visitor.VisitPointer(heap_->native_contexts_list_address());
+  updating_visitor.VisitPointer(&code_to_deoptimize_);
 
   heap_->string_table()->Iterate(&updating_visitor);
 
   // Update pointers from external string table.
   heap_->UpdateReferencesInExternalStringTable(
       &UpdateReferenceInExternalStringTableEntry);
 
   if (!FLAG_watch_ic_patching) {
     // Update JSFunction pointers from the runtime profiler.
     heap()->isolate()->runtime_profiler()->UpdateSamplesAfterCompact(
@@ skipping 843 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal