Make embedded maps in optimized code weak.

src/objects-inl.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 3353 matching lines @@
 void Map::set_is_observed(bool is_observed) {
   set_bit_field3(IsObserved::update(bit_field3(), is_observed));
 }
 
 
 bool Map::is_observed() {
   return IsObserved::decode(bit_field3());
 }
 
 
+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.
   ASSERT((ExtractKindFromFlags(flags) != CALL_IC &&
           ExtractKindFromFlags(flags) != KEYED_CALL_IC) ||
          ExtractArgumentsCountFromFlags(flags) >= 0);
   WRITE_INT_FIELD(this, kFlagsOffset, flags);
 }
 
 
@@ skipping 252 matching lines @@
 
 
 void Code::set_has_function_cache(bool flag) {
   ASSERT(kind() == STUB);
   int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
   int updated = HasFunctionCacheField::update(previous, flag);
   WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
 }
 
 
+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;
 }
 
 
 Code::Flags Code::ComputeFlags(Kind kind,
                                InlineCacheState ic_state,
                                ExtraICState extra_ic_state,
                                StubType type,
@@ skipping 303 matching lines @@
 
 
 HeapObject* Map::UncheckedPrototypeTransitions() {
   ASSERT(HasTransitionArray());
   ASSERT(unchecked_transition_array()->HasPrototypeTransitions());
   return unchecked_transition_array()->UncheckedPrototypeTransitions();
 }
 
 
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
+ACCESSORS(Map, dependent_codes, FixedArray, kDependentCodesOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
 ACCESSORS(JSFunction, literals_or_bindings, FixedArray, kLiteralsOffset)
 ACCESSORS(JSFunction, next_function_link, Object, kNextFunctionLinkOffset)
 
 ACCESSORS(GlobalObject, builtins, JSBuiltinsObject, kBuiltinsOffset)
 ACCESSORS(GlobalObject, native_context, Context, kNativeContextOffset)
 ACCESSORS(GlobalObject, global_context, Context, kGlobalContextOffset)
 ACCESSORS(GlobalObject, global_receiver, JSObject, kGlobalReceiverOffset)
@@ skipping 1778 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_