A64: Synchronize with r18256.

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 79 matching lines @@
       }
       case HValue::kTransitionElementsKind: {
         ReduceTransitionElementsKind(
             HTransitionElementsKind::cast(instr));
         break;
       }
       case HValue::kCheckMapValue: {
         ReduceCheckMapValue(HCheckMapValue::cast(instr));
         break;
       }
+      case HValue::kCheckHeapObject: {
+        ReduceCheckHeapObject(HCheckHeapObject::cast(instr));
+        break;
+      }
       default: {
         // If the instruction changes maps uncontrollably, drop everything.
         if (instr->CheckGVNFlag(kChangesMaps) ||
             instr->CheckGVNFlag(kChangesOsrEntries)) {
           Kill();
         }
       }
       // Improvements possible:
-      // - eliminate HCheckSmi and HCheckHeapObject
+      // - 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) {
     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());
     }
+    if (succ->predecessors()->length() == 1) {
+      HControlInstruction* end = succ->predecessors()->at(0)->end();
+      if (end->IsCompareMap() && end->SuccessorAt(0) == succ) {
+        // Learn on the true branch of if(CompareMap(x)).
+        HCompareMap* cmp = HCompareMap::cast(end);
+        HValue* object = cmp->value()->ActualValue();
+        HCheckTableEntry* entry = copy->Find(object);
+        if (entry == NULL) {
+          copy->Insert(object, cmp->map());
+        } else {
+          MapSet list = new(phase_->zone()) UniqueSet<Map>();
+          list->Add(cmp->map(), phase_->zone());
+          entry->maps_ = list;
+        }
+      }
+      // TODO(titzer): is it worthwhile to learn on false branch too?
+    }
     return copy;
   }
 
   // Global analysis: Merge this state with the other incoming state.
   HCheckTable* Merge(HBasicBlock* succ, HCheckTable* that, Zone* zone) {
     if (that->size_ == 0) {
       // If the other state is empty, simply reset.
       size_ = 0;
       cursor_ = 0;
       return this;
@@ skipping 94 matching lines @@
           maps->Clear();
           maps->Add(map, phase_->zone());
         }
       }
     } else {
       // No prior information.
       Insert(object, map);
     }
   }
 
+  void ReduceCheckHeapObject(HCheckHeapObject* instr) {
+    if (FindMaps(instr->value()->ActualValue()) != NULL) {
+      // If the object has known maps, it's definitely a heap object.
+      instr->DeleteAndReplaceWith(instr->value());
+      INC_STAT(removed_cho_);
+    }
+  }
+
   void ReduceStoreNamedField(HStoreNamedField* instr) {
     HValue* object = instr->object()->ActualValue();
     if (instr->has_transition()) {
       // This store transitions the object to a new map.
       Kill(object);
       Insert(object, MapConstant(instr->transition()));
     } else if (IsMapAccess(instr->access())) {
       // This is a store directly to the map field of the object.
       Kill(object);
       if (!instr->value()->IsConstant()) return;
@@ skipping 232 matching lines @@
     }
   }
 
   if (FLAG_trace_check_elimination) PrintStats();
 }
 
 
 // Are we eliminated yet?
 void HCheckEliminationPhase::PrintStats() {
 #if DEBUG
-  if (redundant_ > 0)      PrintF("  redundant   = %2d\n", redundant_);
-  if (removed_ > 0)        PrintF("  removed     = %2d\n", removed_);
-  if (narrowed_ > 0)       PrintF("  narrowed    = %2d\n", narrowed_);
-  if (loads_ > 0)          PrintF("  loads       = %2d\n", loads_);
-  if (empty_ > 0)          PrintF("  empty       = %2d\n", empty_);
-  if (compares_true_ > 0)  PrintF("  cmp_true    = %2d\n", compares_true_);
-  if (compares_false_ > 0) PrintF("  cmp_false   = %2d\n", compares_false_);
-  if (transitions_ > 0)    PrintF("  transitions = %2d\n", transitions_);
+  #define PRINT_STAT(x) if (x##_ > 0) PrintF(" %-16s = %2d\n", #x, x##_)
+#else
+  #define PRINT_STAT(x)
 #endif
+  PRINT_STAT(redundant);
+  PRINT_STAT(removed);
+  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