Make maps in monomorphic IC stubs weak.

src/objects.cc

 // Copyright 2013 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 4529 matching lines @@
       // except for the code cache, which can contain some ics which can be
       // applied to the shared map.
       Handle<Map> fresh = Map::CopyNormalized(handle(obj->map()), mode,
                                               SHARED_NORMALIZED_MAP);
 
       ASSERT(memcmp(fresh->address(),
                     Handle<Map>::cast(result)->address(),
                     Map::kCodeCacheOffset) == 0);
       STATIC_ASSERT(Map::kDependentCodeOffset ==
                     Map::kCodeCacheOffset + kPointerSize);
-      int offset = Map::kDependentCodeOffset + kPointerSize;
+      STATIC_ASSERT(Map::kDependentICOffset ==
+                    Map::kDependentCodeOffset + kPointerSize);
+      int offset = Map::kDependentICOffset + kPointerSize;
       ASSERT(memcmp(fresh->address() + offset,
                     Handle<Map>::cast(result)->address() + offset,
                     Map::kSize - offset) == 0);
     }
 #endif
     return Handle<Map>::cast(result);
   }
 
   Isolate* isolate = cache->GetIsolate();
   Handle<Map> map = Map::CopyNormalized(handle(obj->map()), mode,
@@ skipping 6967 matching lines @@
 
 
 void Map::AddDependentCode(DependentCode::DependencyGroup group,
                            Handle<Code> code) {
   Handle<DependentCode> codes = DependentCode::Insert(
       Handle<DependentCode>(dependent_code()), group, code);
   if (*codes != dependent_code()) set_dependent_code(*codes);
 }
 
 
+void Map::AddDependentIC(Handle<Code> stub) {
+  ASSERT(stub->next_code_link()->IsUndefined());
+  stub->set_next_code_link(dependent_ic());
+  set_dependent_ic(*stub);
+}
+
+
 DependentCode::GroupStartIndexes::GroupStartIndexes(DependentCode* entries) {
   Recompute(entries);
 }
 
 
 void DependentCode::GroupStartIndexes::Recompute(DependentCode* entries) {
   start_indexes_[0] = 0;
   for (int g = 1; g <= kGroupCount; g++) {
     int count = entries->number_of_entries(static_cast<DependencyGroup>(g - 1));
     start_indexes_[g] = start_indexes_[g - 1] + count;
@@ skipping 4913 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal