Change heuristics for deciding phi-representation types to use int32 more frequently.

src/hydrogen.cc

 // Copyright 2011 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 1557 matching lines @@
   int double_count = use_count[Representation::kDouble];
   int int32_count = use_count[Representation::kInteger32];
   int non_tagged_count = double_count + int32_count;
 
   // If a non-loop phi has tagged uses, don't convert it to untagged.
   if (value->IsPhi() && !value->block()->IsLoopHeader()) {
     if (tagged_count > 0) return Representation::None();
   }
 
   if (non_tagged_count >= tagged_count) {
-    // More untagged than tagged.
-    if (double_count > 0) {
-      // There is at least one usage that is a double => guess that the
-      // correct representation is double.
-      return Representation::Double();
+    if (int32_count > 0 && value->IsPhi()) {

[Kevin Millikin (Chromium), 2011/05/03 07:58:32]

if (int32_count > 0) {
  if (!value->IsPhi() || value->IsConvertibleToInteger()) {
    return Representation::Integer32();
  }
}
if (double_count > 0) ...
    

+      HPhi* phi = HPhi::cast(value);
+      if (phi->IsConvertibleToInteger()) return Representation::Integer32();
     } else if (int32_count > 0) {
       return Representation::Integer32();
     }
+    if (double_count > 0) return Representation::Double();
   }
   return Representation::None();
 }
 
 
 void HInferRepresentation::Analyze() {
   HPhase phase("Infer representations", graph_);
 
   // (1) Initialize bit vectors and count real uses. Each phi gets a
   // bit-vector of length <number of phis>.
   const ZoneList<HPhi*>* phi_list = graph_->phi_list();
   int phi_count = phi_list->length();
-  ScopedVector<BitVector*> connected_phis(phi_count);
+  ZoneList<BitVector*> connected_phis(phi_count);
   for (int i = 0; i < phi_count; ++i) {
     phi_list->at(i)->InitRealUses(i);
     connected_phis[i] = new(zone()) BitVector(phi_count);
     connected_phis[i]->Add(i);
   }
 
   // (2) Do a fixed point iteration to find the set of connected phis.  A
   // phi is connected to another phi if its value is used either directly or
   // indirectly through a transitive closure of the def-use relation.
   bool change = true;
@@ skipping 20 matching lines @@
          !it.Done();
          it.Advance()) {
       int index = it.Current();
       if (index != i) {
         HPhi* it_use = phi_list->at(it.Current());
         phi->AddNonPhiUsesFrom(it_use);
       }
     }
   }
 
+  // (4) Compute phis that definitely can't be converted to integer
+  // without deoptimization and mark them to avoid unnecessary deoptimization.
+  change = true;
+  while (change) {
+    change = false;
+    for (int i = 0; i < phi_count; i++) {

[Kevin Millikin (Chromium), 2011/05/03 07:58:32]

All the other loops in this function use new-school ++i :)

+      HPhi* phi = phi_list->at(i);
+      for (int i = 0; i < phi->OperandCount(); i++) {

[Kevin Millikin (Chromium), 2011/05/03 07:58:32]

Please don't shadow the outer loop index even if you don't need it in the inner
loop!

+        if (phi->IsConvertibleToInteger() &&
+            !phi->OperandAt(i)->IsConvertibleToInteger()) {
+          phi->set_is_convertible_to_integer(false);
+          change = true;
+          break;
+        }
+      }
+    }
+  }
+
+
   for (int i = 0; i < graph_->blocks()->length(); ++i) {
     HBasicBlock* block = graph_->blocks()->at(i);
     const ZoneList<HPhi*>* phis = block->phis();
     for (int j = 0; j < phis->length(); ++j) {
       AddToWorklist(phis->at(j));
     }
 
     HInstruction* current = block->first();
     while (current != NULL) {
       AddToWorklist(current);
@@ skipping 4428 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal