Turn polymorphic stores monomorphic if store sequence matches.

src/hydrogen.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 7174 matching lines @@
   return ast_context()->ReturnInstruction(instr, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::HandlePolymorphicStoreNamedField(
     Assignment* expr,
     HValue* object,
     HValue* value,
     SmallMapList* types,
     Handle<String> name) {
+  if (types->length() <= kMaxStorePolymorphism) {
+    int previous_field_offset = 0;
+    bool previous_field_is_in_object = false;
+    Representation previous_representation = Representation::None();
+
+    Handle<Map> map;
+    LookupResult lookup(isolate());
+    int count;
+    for (count = 0; count < types->length(); ++count) {
+      map = types->at(count);
+      if (!ComputeLoadStoreField(map, name, &lookup, false) ||
+          lookup.IsTransition()) {
+        break;
+      }
+      Representation representation = lookup.representation();
+      int index = ComputeLoadStoreFieldIndex(map, &lookup);
+      bool is_in_object = index < 0;
+      int offset = index * kPointerSize;
+      if (index < 0) {
+        offset += map->instance_size();
+      } else {
+        offset += FixedArray::kHeaderSize;
+      }
+      if (count == 0) {
+        previous_field_offset = offset;
+        previous_field_is_in_object = is_in_object;
+        previous_representation = representation;
+      } else if (offset != previous_field_offset ||
+                 is_in_object != previous_field_is_in_object ||
+                 !representation.IsCompatibleForStore(
+                     previous_representation)) {
+        break;
+      }
+    }
+
+    if (types->length() == count) {
+      AddInstruction(new(zone()) HCheckNonSmi(object));
+      AddInstruction(HCheckMaps::New(object, types, zone()));
+      HInstruction* instr = BuildStoreNamedField(
+          object, name, value, map, &lookup);
+      instr->set_position(expr->position());
+      return ast_context()->ReturnInstruction(instr, expr->id());
+    }
+  }
+
   // TODO(ager): We should recognize when the prototype chains for different
   // maps are identical. In that case we can avoid repeatedly generating the
   // same prototype map checks.
   int count = 0;
   HBasicBlock* join = NULL;
   for (int i = 0; i < types->length() && count < kMaxStorePolymorphism; ++i) {
     Handle<Map> map = types->at(i);
     LookupResult lookup(isolate());
     if (ComputeLoadStoreField(map, name, &lookup, true)) {
       if (count == 0) {
@@ skipping 5068 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal