Eliminatable CheckMaps replaced with if(true) or if(false).

src/hydrogen-check-elimination.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 100 matching lines @@
       // Improvements possible:
       // - eliminate redundant HCheckSmi, HCheckInstanceType instructions
       // - track which values have been HCheckHeapObject'd
     }
 
     return this;
   }
 
   // Global analysis: Copy state to successor block.
   HCheckTable* Copy(HBasicBlock* succ, Zone* zone) {
+    ASSERT(succ->IsReachable());
+
     HCheckTable* copy = new(phase_->zone()) HCheckTable(phase_);
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* old_entry = &entries_[i];
       HCheckTableEntry* new_entry = &copy->entries_[i];
       // TODO(titzer): keep the check if this block dominates the successor?
       new_entry->object_ = old_entry->object_;
       new_entry->check_ = NULL;
       new_entry->maps_ = old_entry->maps_->Copy(phase_->zone());
     }
     copy->cursor_ = cursor_;
@@ skipping 36 matching lines @@
         }
       }
       // Learning on false branches requires storing negative facts.
     }
 
     return copy;
   }
 
   // Global analysis: Merge this state with the other incoming state.
   HCheckTable* Merge(HBasicBlock* succ, HCheckTable* that, Zone* zone) {
+    ASSERT(succ->IsReachable());
+
     if (that->size_ == 0) {
       // If the other state is empty, simply reset.
       size_ = 0;
       cursor_ = 0;
       return this;
     }
     bool compact = false;
     for (int i = 0; i < size_; i++) {
       HCheckTableEntry* this_entry = &entries_[i];
       HCheckTableEntry* that_entry = that->Find(this_entry->object_);
@@ skipping 117 matching lines @@
       Insert(object, MapConstant(instr->value()));
     } else {
       // If the instruction changes maps, it should be handled above.
       CHECK(!instr->CheckGVNFlag(kChangesMaps));
     }
   }
 
   void ReduceCompareMap(HCompareMap* instr) {
     MapSet maps = FindMaps(instr->value()->ActualValue());
     if (maps == NULL) return;
+
+    TRACE(("CompareMap for #%d at B%d ",
+        instr->value()->ActualValue()->id(), instr->block()->block_id()));
+
     if (maps->Contains(instr->map())) {
       if (maps->size() == 1) {
-        // TODO(titzer): replace with goto true branch
         INC_STAT(compares_true_);
+
+        TRACE(("replaced with goto B%d (true target)\n",
+               instr->SuccessorAt(0)->block_id()));
+
+        instr->block()->ReplaceControlWithGotoSuccessor(0);
+      } else {
+        TRACE(("can't be replaced with goto: ambiguous set of maps\n"));
       }
     } else {
-      // TODO(titzer): replace with goto false branch
       INC_STAT(compares_false_);
+      TRACE(("replaced with goto B%d (false target)\n",
+             instr->SuccessorAt(1)->block_id()));
+
+      instr->block()->ReplaceControlWithGotoSuccessor(1);
     }
   }
 
   void ReduceTransitionElementsKind(HTransitionElementsKind* instr) {
     MapSet maps = FindMaps(instr->object()->ActualValue());
     // Can only learn more about an object that already has a known set of maps.
     if (maps == NULL) return;
     if (maps->Contains(instr->original_map())) {
       // If the object has the original map, it will be transitioned.
       maps->Remove(instr->original_map());
@@ skipping 220 matching lines @@
   PRINT_STAT(removed_cho);
   PRINT_STAT(narrowed);
   PRINT_STAT(loads);
   PRINT_STAT(empty);
   PRINT_STAT(compares_true);
   PRINT_STAT(compares_false);
   PRINT_STAT(transitions);
 }
 
 } }  // namespace v8::internal