Reland: "Use stability to only conditionally flush information from the CheckMaps table."

src/hydrogen.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 1372 matching lines @@
 
 
 HValue* HGraphBuilder::BuildCopyElementsOnWrite(HValue* object,
                                                 HValue* elements,
                                                 ElementsKind kind,
                                                 HValue* length) {
   Factory* factory = isolate()->factory();
 
   IfBuilder cow_checker(this);
 
-  cow_checker.If<HCompareMap>(elements, factory->fixed_cow_array_map());
+  cow_checker.If<HCompareMap>(
+      elements, factory->fixed_cow_array_map(), top_info());
   cow_checker.Then();
 
   HValue* capacity = AddLoadFixedArrayLength(elements);
 
   HValue* new_elements = BuildGrowElementsCapacity(object, elements, kind,
                                                    kind, length, capacity);
 
   environment()->Push(new_elements);
 
   cow_checker.Else();
@@ skipping 296 matching lines @@
     if_objectiskey.JoinContinuation(&found);
   }
   if_objectissmi.Else();
   {
     if (type->Is(Type::Smi())) {
       if_objectissmi.Deopt("Expected smi");
     } else {
       // Check if the object is a heap number.
       IfBuilder if_objectisnumber(this);
       HValue* objectisnumber = if_objectisnumber.If<HCompareMap>(
-          object, isolate()->factory()->heap_number_map());
+          object, isolate()->factory()->heap_number_map(), top_info());
       if_objectisnumber.Then();
       {
         // Compute hash for heap number similar to double_get_hash().
         HValue* low = Add<HLoadNamedField>(
             object, objectisnumber,
             HObjectAccess::ForHeapNumberValueLowestBits());
         HValue* high = Add<HLoadNamedField>(
             object, objectisnumber,
             HObjectAccess::ForHeapNumberValueHighestBits());
         HValue* hash = AddUncasted<HBitwise>(Token::BIT_XOR, low, high);
@@ skipping 3923 matching lines @@
       }
     }
     ++count;
     HBasicBlock* if_true = graph()->CreateBasicBlock();
     HBasicBlock* if_false = graph()->CreateBasicBlock();
     HUnaryControlInstruction* compare;
 
     HValue* dependency;
     if (info.type()->Is(Type::Number())) {
       Handle<Map> heap_number_map = isolate()->factory()->heap_number_map();
-      compare = New<HCompareMap>(object, heap_number_map, if_true, if_false);
+      compare = New<HCompareMap>(object, heap_number_map, top_info(),
+                                 if_true, if_false);
       dependency = smi_check;
     } else if (info.type()->Is(Type::String())) {
       compare = New<HIsStringAndBranch>(object, if_true, if_false);
       dependency = compare;
     } else {
-      compare = New<HCompareMap>(object, info.map(), if_true, if_false);
+      compare = New<HCompareMap>(object, info.map(), top_info(),
+                                 if_true, if_false);
       dependency = compare;
     }
     FinishCurrentBlock(compare);
 
     if (info.type()->Is(Type::Number())) {
       Goto(if_true, number_block);
       if_true = number_block;
       number_block->SetJoinId(ast_id);
     }
 
@@ skipping 619 matching lines @@
     // Remember the most general elements kind, the code for its load will
     // properly handle all of the more specific cases.
     if ((i == 0) || IsMoreGeneralElementsKindTransition(
             most_general_consolidated_map->elements_kind(),
             map->elements_kind())) {
       most_general_consolidated_map = map;
     }
   }
   if (!has_double_maps && !has_smi_or_object_maps) return NULL;
 
-  HCheckMaps* checked_object = Add<HCheckMaps>(object, maps);
+  HCheckMaps* checked_object = Add<HCheckMaps>(object, maps, top_info());
   // FAST_ELEMENTS is considered more general than FAST_HOLEY_SMI_ELEMENTS.
   // If we've seen both, the consolidated load must use FAST_HOLEY_ELEMENTS.
   ElementsKind consolidated_elements_kind = has_seen_holey_elements
       ? GetHoleyElementsKind(most_general_consolidated_map->elements_kind())
       : most_general_consolidated_map->elements_kind();
   HInstruction* instr = BuildUncheckedMonomorphicElementAccess(
       checked_object, key, val,
       most_general_consolidated_map->instance_type() == JS_ARRAY_TYPE,
       consolidated_elements_kind,
       LOAD, NEVER_RETURN_HOLE, STANDARD_STORE);
@@ skipping 77 matching lines @@
 
   HBasicBlock* join = graph()->CreateBasicBlock();
 
   for (int i = 0; i < untransitionable_maps.length(); ++i) {
     Handle<Map> map = untransitionable_maps[i];
     if (!map->IsJSObjectMap()) continue;
     ElementsKind elements_kind = map->elements_kind();
     HBasicBlock* this_map = graph()->CreateBasicBlock();
     HBasicBlock* other_map = graph()->CreateBasicBlock();
     HCompareMap* mapcompare =
-        New<HCompareMap>(object, map, this_map, other_map);
+        New<HCompareMap>(object, map, top_info(), this_map, other_map);
     FinishCurrentBlock(mapcompare);
 
     set_current_block(this_map);
     HInstruction* access = NULL;
     if (IsDictionaryElementsKind(elements_kind)) {
       access = AddInstruction(BuildKeyedGeneric(access_type, object, key, val));
     } else {
       ASSERT(IsFastElementsKind(elements_kind) ||
              IsExternalArrayElementsKind(elements_kind));
       LoadKeyedHoleMode load_mode = BuildKeyedHoleMode(map);
@@ skipping 187 matching lines @@
     }
 
     HValue* checked_object;
     // Type::Number() is only supported by polymorphic load/call handling.
     ASSERT(!info.type()->Is(Type::Number()));
     BuildCheckHeapObject(object);
     if (AreStringTypes(types)) {
       checked_object =
           Add<HCheckInstanceType>(object, HCheckInstanceType::IS_STRING);
     } else {
-      checked_object = Add<HCheckMaps>(object, types);
+      checked_object = Add<HCheckMaps>(object, types, top_info());
     }
     return BuildMonomorphicAccess(
         &info, object, checked_object, value, ast_id, return_id);
   }
 
   return BuildNamedGeneric(access, object, name, value, is_uninitialized);
 }
 
 
 void HOptimizedGraphBuilder::PushLoad(Property* expr,
@@ skipping 231 matching lines @@
       }
     }
     ++count;
     HBasicBlock* if_true = graph()->CreateBasicBlock();
     HBasicBlock* if_false = graph()->CreateBasicBlock();
     HUnaryControlInstruction* compare;
 
     Handle<Map> map = info.map();
     if (info.type()->Is(Type::Number())) {
       Handle<Map> heap_number_map = isolate()->factory()->heap_number_map();
-      compare = New<HCompareMap>(receiver, heap_number_map, if_true, if_false);
+      compare = New<HCompareMap>(receiver, heap_number_map, top_info(),
+                                 if_true, if_false);
     } else if (info.type()->Is(Type::String())) {
       compare = New<HIsStringAndBranch>(receiver, if_true, if_false);
     } else {
-      compare = New<HCompareMap>(receiver, map, if_true, if_false);
+      compare = New<HCompareMap>(receiver, map, top_info(),
+                                 if_true, if_false);
     }
     FinishCurrentBlock(compare);
 
     if (info.type()->Is(Type::Number())) {
       Goto(if_true, number_block);
       if_true = number_block;
       number_block->SetJoinId(expr->id());
     }
 
     set_current_block(if_true);
@@ skipping 824 matching lines @@
     PrintF("Inlining api function ");
     function->ShortPrint();
     PrintF("\n");
   }
 
   bool drop_extra = false;
   switch (call_type) {
     case kCallApiFunction:
     case kCallApiMethod:
       // Need to check that none of the receiver maps could have changed.
-      Add<HCheckMaps>(receiver, receiver_maps);
+      Add<HCheckMaps>(receiver, receiver_maps, top_info());
       // Need to ensure the chain between receiver and api_holder is intact.
       if (holder_lookup == CallOptimization::kHolderFound) {
         AddCheckPrototypeMaps(api_holder, receiver_maps->first());
       } else {
         ASSERT_EQ(holder_lookup, CallOptimization::kHolderIsReceiver);
       }
       // Includes receiver.
       PushArgumentsFromEnvironment(argc + 1);
       // Drop function after call.
       drop_extra = true;
@@ skipping 3464 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal