Use weak cells in dependent code.

src/lithium.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/lithium.h"
 
 #include "src/v8.h"
 
 #include "src/scopes.h"
 #include "src/serialize.h"
@@ skipping 396 matching lines @@
 }
 
 
 Representation LChunk::LookupLiteralRepresentation(
     LConstantOperand* operand) const {
   return graph_->LookupValue(operand->index())->representation();
 }
 
 
 static void AddWeakObjectToCodeDependency(Isolate* isolate,
-                                          Handle<Object> object,
+                                          Handle<HeapObject> object,
                                           Handle<Code> code) {
+  Handle<WeakCell> cell = Code::WeakCellFor(code);
   Heap* heap = isolate->heap();
-  heap->EnsureWeakObjectToCodeTable();
   Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(object));
-  dep = DependentCode::Insert(dep, DependentCode::kWeakCodeGroup, code);
+  dep = DependentCode::InsertWeakCode(dep, DependentCode::kWeakCodeGroup, cell);
   heap->AddWeakObjectToCodeDependency(object, dep);
 }
 
 
 void LChunk::RegisterWeakObjectsInOptimizedCode(Handle<Code> code) const {
   DCHECK(code->is_optimized_code());
   ZoneList<Handle<Map> > maps(1, zone());
   ZoneList<Handle<HeapObject> > objects(1, zone());
   int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                   RelocInfo::ModeMask(RelocInfo::CELL);
@@ skipping 22 matching lines @@
   }
   if (FLAG_enable_ool_constant_pool) {
     code->constant_pool()->set_weak_object_state(
         ConstantPoolArray::WEAK_OBJECTS_IN_OPTIMIZED_CODE);
   }
   code->set_can_have_weak_objects(true);
 }
 
 
 void LChunk::CommitDependencies(Handle<Code> code) const {
+  if (!code->is_optimized_code()) return;
+  HandleScope scope(isolate());
+
   for (MapSet::const_iterator it = deprecation_dependencies_.begin(),
        iend = deprecation_dependencies_.end(); it != iend; ++it) {
     Handle<Map> map = *it;
     DCHECK(!map->is_deprecated());
     DCHECK(map->CanBeDeprecated());
     Map::AddDependentCode(map, DependentCode::kTransitionGroup, code);
   }
 
   for (MapSet::const_iterator it = stability_dependencies_.begin(),
        iend = stability_dependencies_.end(); it != iend; ++it) {
     Handle<Map> map = *it;
     DCHECK(map->is_stable());
     DCHECK(map->CanTransition());
     Map::AddDependentCode(map, DependentCode::kPrototypeCheckGroup, code);
   }
 
   info_->CommitDependencies(code);
-  if (code->is_optimized_code()) RegisterWeakObjectsInOptimizedCode(code);
+  RegisterWeakObjectsInOptimizedCode(code);
 }
 
 
 LChunk* LChunk::NewChunk(HGraph* graph) {
   DisallowHandleAllocation no_handles;
   DisallowHeapAllocation no_gc;
   graph->DisallowAddingNewValues();
   int values = graph->GetMaximumValueID();
   CompilationInfo* info = graph->info();
   if (values > LUnallocated::kMaxVirtualRegisters) {
@@ skipping 221 matching lines @@
 
 
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 } }  // namespace v8::internal