Make embedded maps in optimized code weak.

src/objects-inl.h

Index: src/objects-inl.h
diff --git a/src/objects-inl.h b/src/objects-inl.h
index d678a1209cf76e80302671b18d29e3d5c7921a96..dd80e8cd9d962dd98c2ecf39f7801eadabbb1509 100644
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -3371,6 +3371,47 @@ bool Map::is_observed() {
 }
 
 
+void Map::AddDependentCode(Handle<Code> code) {
+  Handle<FixedArray> codes =
+      DependentCodes::Append(Handle<FixedArray>(dependent_codes()), code);
+  if (*codes != dependent_codes()) {
+    set_dependent_codes(*codes);
+  }
+}
+
+
+int DependentCodes::number_of_codes(FixedArray* codes) {
+  if (codes->length() == 0) return 0;
+  return Smi::cast(codes->get(kNumberOfCodesOffset))->value();
+}
+
+
+void DependentCodes::set_number_of_codes(FixedArray* codes, int value) {
+  codes->set(kNumberOfCodesOffset, Smi::FromInt(value));
+}
+
+
+Code* DependentCodes::code(FixedArray* codes, int i) {
+  return Code::cast(codes->get(kCodesOffset + i));
+}
+
+
+void DependentCodes::set_code(FixedArray* codes, int i, Code* value) {
+  codes->set(kCodesOffset + i, value);
+}
+
+
+Object** DependentCodes::code_slot(FixedArray* codes, int i) {
+  return HeapObject::RawField(
+      codes, FixedArray::OffsetOfElementAt(kCodesOffset + i));
+}
+
+
+void DependentCodes::clear_code(FixedArray* codes, int i) {
+  codes->set(kCodesOffset + i, Smi::FromInt(0), SKIP_WRITE_BARRIER);
+}
+
+
 void Code::set_flags(Code::Flags flags) {
   STATIC_ASSERT(Code::NUMBER_OF_KINDS <= KindField::kMax + 1);
   // Make sure that all call stubs have an arguments count.
@@ -3643,6 +3684,21 @@ void Code::set_has_function_cache(bool flag) {
 }
 
 
+bool Code::marked_for_deoptimization() {
+  ASSERT(kind() == OPTIMIZED_FUNCTION);
+  return MarkedForDeoptimizationField::decode(
+      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+}
+
+
+void Code::set_marked_for_deoptimization(bool flag) {
+  ASSERT(kind() == OPTIMIZED_FUNCTION);
+  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int updated = MarkedForDeoptimizationField::update(previous, flag);
+  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+}
+
+
 bool Code::is_inline_cache_stub() {
   Kind kind = this->kind();
   return kind >= FIRST_IC_KIND && kind <= LAST_IC_KIND;
@@ -3966,6 +4022,7 @@ HeapObject* Map::UncheckedPrototypeTransitions() {
 
 
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
+ACCESSORS(Map, dependent_codes, FixedArray, kDependentCodesOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)