Don't take UnkownOSRValues into account when infering Phi's representation.

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 1748 matching lines @@
 // This method tries to specialize the representation type of the value
 // given as a parameter. The value is asked to infer its representation type
 // based on its inputs. If the inferred type is more specialized, then this
 // becomes the new representation type of the node.
 void HInferRepresentation::InferBasedOnInputs(HValue* current) {
   Representation r = current->representation();
   if (r.IsSpecialization()) return;
   ASSERT(current->CheckFlag(HValue::kFlexibleRepresentation));
   Representation inferred = current->InferredRepresentation();
   if (inferred.IsSpecialization()) {
+    if (FLAG_trace_representation) {
+      PrintF("Changing #%d representation %s -> %s based on inputs\n",
+             current->id(),
+             r.Mnemonic(),
+             inferred.Mnemonic());
+    }
     current->ChangeRepresentation(inferred);
     AddDependantsToWorklist(current);
   }
 }
 
 
 void HInferRepresentation::AddDependantsToWorklist(HValue* value) {
   for (HUseIterator it(value->uses()); !it.Done(); it.Advance()) {
     AddToWorklist(it.value());
   }
   for (int i = 0; i < value->OperandCount(); ++i) {
     AddToWorklist(value->OperandAt(i));
   }
 }
 
 
 // This method calculates whether specializing the representation of the value
 // given as the parameter has a benefit in terms of less necessary type
 // conversions. If there is a benefit, then the representation of the value is
 // specialized.
 void HInferRepresentation::InferBasedOnUses(HValue* value) {
   Representation r = value->representation();
   if (r.IsSpecialization() || value->HasNoUses()) return;
   ASSERT(value->CheckFlag(HValue::kFlexibleRepresentation));
   Representation new_rep = TryChange(value);
   if (!new_rep.IsNone()) {
     if (!value->representation().Equals(new_rep)) {
+      if (FLAG_trace_representation) {
+        PrintF("Changing #%d representation %s -> %s based on uses\n",
+               value->id(),
+               r.Mnemonic(),
+               new_rep.Mnemonic());
+      }
       value->ChangeRepresentation(new_rep);
       AddDependantsToWorklist(value);
     }
   }
 }
 
 
 Representation HInferRepresentation::TryChange(HValue* value) {
   // Array of use counts for each representation.
   int use_count[Representation::kNumRepresentations] = { 0 };
@@ skipping 6300 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal