Make objects embedded in optimized code weak.

src/heap.h

 // 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 1868 matching lines @@
 
 #ifdef DEBUG
     static bool IsLockedByOptimizerThread(Heap* heap) {
       return heap->relocation_mutex_locked_by_optimizer_thread_;
     }
 #endif  // DEBUG
 
    private:
     Heap* heap_;
   };
 

[Hannes Payer (out of office), 2013/10/01 13:13:50]

What about?
- Making weak_object_to_code, weak_object_to_code_address, and
set_weak_object_to_code private?
- Adding an InitializeWeakObjectToCodeTable which calls
set_weak_object_to_code(isolate_->heap()->undefined_value()).
- Creating the WeakHashtable when accessing the non-initialized hash table.

[ulan, 2013/10/01 14:50:29]

I moved these methods up to the methods of the existing weak lists (like
allocation_sites_list). We need these methods public because mark_compact
accesses the table.

+  Object* weak_object_to_code() {
+    return weak_object_to_code_;
+  }
+
+  Object** weak_object_to_code_address() {
+    return &weak_object_to_code_;
+  }
+
+  void set_weak_object_to_code(Object* value) {
+    ASSERT(!InNewSpace(value));
+    weak_object_to_code_ = value;
+  }
+
+  MaybeObject* AddWeakObjectToCodeDependency(Object* obj, DependentCode* dep);
+
+  DependentCode* LookupWeakObjectToCodeDependency(Object* obj);
+
  private:
   Heap();
 
   // This can be calculated directly from a pointer to the heap; however, it is
   // more expedient to get at the isolate directly from within Heap methods.
   Isolate* isolate_;
 
   Object* roots_[kRootListLength];
 
   intptr_t code_range_size_;
@@ skipping 458 matching lines @@
 
   VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
 
   MemoryChunk* chunks_queued_for_free_;
 
   Mutex* relocation_mutex_;
 #ifdef DEBUG
   bool relocation_mutex_locked_by_optimizer_thread_;
 #endif  // DEBUG;
 
+  // WeakHashTable that maps objects embedded in optimized code to dependent
+  // code list. It is initilized lazily and contains the undefined_value at
+  // start.
+  Object* weak_object_to_code_;

[Hannes Payer (out of office), 2013/10/01 13:13:50]

Can we move that up to the other weak list heads, after allocation_sites_list_?
Moreover, the comment about the initialization applies also to the other weak
lists, we could add it on top of the list heads. Aaand, can we change the name
to weak_object_to_code_table_.

[ulan, 2013/10/01 14:50:29]

Done.

+
   friend class Factory;
   friend class GCTracer;
   friend class DisallowAllocationFailure;
   friend class AlwaysAllocateScope;
   friend class Page;
   friend class Isolate;
   friend class MarkCompactCollector;
   friend class MarkCompactMarkingVisitor;
   friend class MapCompact;
 #ifdef VERIFY_HEAP
@@ skipping 662 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_