Make maps in monomorphic IC stubs weak.

src/ic.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 417 matching lines @@
     info->change_own_type_change_checksum();
   }
   host->set_profiler_ticks(0);
   isolate->runtime_profiler()->NotifyICChanged();
   // TODO(2029): When an optimized function is patched, it would
   // be nice to propagate the corresponding type information to its
   // unoptimized version for the benefit of later inlining.
 }
 
 
+void IC::RegisterWeakMapDependency(Handle<Code> stub) {
+  if (FLAG_collect_maps && FLAG_weak_embedded_maps_in_ic) {
+    if (stub->is_weak_stub()) {
+      MapHandleList maps;
+      int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
+      for (RelocIterator it(*stub, mode_mask); !it.done(); it.next()) {
+        if (it.rinfo()->target_object()->IsMap()) {
+          Handle<Map> map(Map::cast(it.rinfo()->target_object()));
+          if (stub->IsWeakObject(*map)) {
+            maps.Add(map);
+          }
+        }
+      }
+#ifdef VERIFY_HEAP
+      // This disables verification of weak embedded maps after full GC.
+      // AddDependentCode can cause a GC, which would observe the state where
+      // this code is not yet in the depended code lists of the embedded maps.
+      NoWeakObjectVerificationScope disable_verification_of_objects;
+#endif
+      for (int i = 0; i < maps.length(); i++) {
+        maps.at(i)->AddDependentCode(DependentCode::kWeaklyEmbeddedGroup, stub);

[Toon Verwaest, 2014/04/03 15:18:36]

This means that all maps have 2 pointers to monomorphic ICs, once in the code
cache, and once in the dependency list. Can we unify?

Can we avoid clearing the code cache now that those pointers are weak?

[ulan, 2014/04/03 15:40:26]

As discussed offline, we can probably do that if linear search time is ok.

+      }
+    }
+  }
+}
+
+
+Code* IC::MissBuiltin(Isolate* isolate, Code* stub) {
+  switch (stub->kind()) {
+    case Code::LOAD_IC:
+    case Code::STORE_IC:
+    case Code::KEYED_LOAD_IC:
+    case Code::KEYED_STORE_IC: {
+      return isolate->builtins()->builtin(
+                BaseLoadStoreStubCompiler::MissBuiltin(stub->kind()));

[Toon Verwaest, 2014/04/03 15:18:36]

4-space indent

[ulan, 2014/04/03 15:40:26]

Done.

+    }
+    case Code::COMPARE_NIL_IC: {
+      ExtraICState state = stub->extra_ic_state();
+      CompareNilICStub stub(state, HydrogenCodeStub::UNINITIALIZED);
+      stub.ClearState();
+      Code* code = NULL;
+      CHECK(stub.FindCodeInCache(&code, isolate));
+      return code;
+    }
+    default:
+      UNREACHABLE();
+  }
+  return NULL;
+}
+
+
+void IC::InvalidateMapsAndHandlers(Code* stub) {
+  ASSERT(stub->is_weak_stub());
+  Isolate* isolate = stub->GetIsolate();
+  Heap* heap = isolate->heap();
+  Code* miss = MissBuiltin(isolate, stub);
+  Object* undefined = heap->undefined_value();
+  int mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
+                  RelocInfo::ModeMask(RelocInfo::CODE_TARGET);
+  // Set every map to undefined and every code target to the miss builtin.
+  for (RelocIterator it(stub, mode_mask); !it.done(); it.next()) {
+    RelocInfo::Mode mode = it.rinfo()->rmode();
+    if (mode == RelocInfo::EMBEDDED_OBJECT &&
+        it.rinfo()->target_object()->IsMap()) {
+      it.rinfo()->set_target_object(undefined, SKIP_WRITE_BARRIER);
+    } else if (mode == RelocInfo::CODE_TARGET) {
+      Address address = it.rinfo()->pc();
+      Assembler::set_target_address_at(
+          address, stub, miss->instruction_start());
+      if (heap->gc_state() == Heap::MARK_COMPACT) {
+        heap->mark_compact_collector()->RecordCodeTargetPatch(address, miss);
+      } else {
+        heap->incremental_marking()->RecordCodeTargetPatch(address, miss);
+      }
+    }
+  }
+  CPU::FlushICache(stub->instruction_start(), stub->instruction_size());
+}
+
+
 void IC::Clear(Isolate* isolate, Address address,
     ConstantPoolArray* constant_pool) {
   Code* target = GetTargetAtAddress(address, constant_pool);
 
   // Don't clear debug break inline cache as it will remove the break point.
   if (target->is_debug_stub()) return;
 
   switch (target->kind()) {
     case Code::LOAD_IC:
       return LoadIC::Clear(isolate, address, target, constant_pool);
@@ skipping 2385 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal