Remove prototype checks for leaf maps in optimized code.

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index a72585d696948c827a1659fb0d0c201003b9ac11..4a38c1f43141944dd82a4be3f458d1d8f4aa8fb2 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -3624,6 +3624,7 @@ MaybeObject* JSObject::NormalizeProperties(PropertyNormalizationMode mode,
   }
 
   set_map(new_map);
+  map_of_this->DeoptimizeDependentCodes(DependentCodes::kPrototypeCheckGroup);
 
   set_properties(dictionary);
 
@@ -5292,6 +5293,7 @@ MaybeObject* Map::CopyDropDescriptors() {
   result->set_pre_allocated_property_fields(pre_allocated_property_fields());
   result->set_is_shared(false);
   result->ClearCodeCache(GetHeap());
+  DeoptimizeDependentCodes(DependentCodes::kPrototypeCheckGroup);

[Toon Verwaest, 2013/02/11 12:23:45]

Placing this in CopyDropDescriptors is probably a bit too heavy-weight, given
that you only care about this when transitions are added. I presume you could
rather use the Map::AddTransition api as entry-point to deoptimize. It already
special-cases for the case that you are adding the first transition.

[ulan, 2013/02/12 13:42:07]

As discussed offline, adding abstraction function here to track object layout
changes that not necessarily lead to AddTransition.

   return result;
 }
 
@@ -9555,6 +9557,37 @@ bool DependentCodes::Contains(DependencyGroup group, Code* code) {
   return false;
 }
 
+class DeoptimizeDependentCodeFilter : public OptimizedFunctionFilter {
+ public:
+  virtual bool TakeFunction(JSFunction* function) {
+    return function->code()->marked_for_deoptimization();
+  }
+};
+
+
+void Map::DeoptimizeDependentCodes(DependentCodes::DependencyGroup group) {
+  AssertNoAllocation no_allocation_scope;
+  DependentCodes* codes = dependent_codes();
+  DependentCodes::GroupStartIndexes starts;
+  codes->ComputeGroupStartIndexes(starts);
+  int start = starts[group];
+  int end = starts[group + 1];
+  int number_of_codes = starts[DependentCodes::kGroupCount];
+  if (start == end) return;
+  for (int i = start; i < end; i++) {
+    Code* code = codes->code_at(i);
+    if (!code->marked_for_deoptimization()) {
+      code->set_marked_for_deoptimization(true);
+    }

[Toon Verwaest, 2013/02/11 12:23:45]

I guess the if(!..) { } is not necessary; since after you go over it, it'll
always be set to true. I presume set_marked doesn't trigger extra computation
given that it's lowercase; but if it does, you could move the condition in that
method.

[ulan, 2013/02/12 13:42:07]

Done.

+  }

[Toon Verwaest, 2013/02/11 12:23:45]

I don't particularly like this API. It seems like we'd want to have an iterator
here. Also codes->Compute...(starts) seems a bit odd. Why not just
::GroupStartIndexes starts(codes) and let the constructor compute?

[ulan, 2013/02/12 13:42:07]

Done.

+  for (int src = end, dst = start; src < number_of_codes; src++, dst++) {
+    codes->set_code_at(dst, codes->code_at(src));
+  }
+  codes->set_number_of_codes(group, 0);
+  DeoptimizeDependentCodeFilter filter;
+  Deoptimizer::DeoptimizeAllFunctionsWith(&filter);
+}
+
 
 MaybeObject* JSReceiver::SetPrototype(Object* value,
                                       bool skip_hidden_prototypes) {