Ignore observed Double output in binary operations when all uses are truncating to Integer32

src/hydrogen-instructions.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 2214 matching lines @@
   if (!observed_output_representation_.IsNone()) return;
   new_rep = RepresentationFromUses();
   UpdateRepresentation(new_rep, h_infer, "uses");
 }
 
 
 Representation HBinaryOperation::RepresentationFromInputs() {
   // Determine the worst case of observed input representations and
   // the currently assumed output representation.
   Representation rep = representation();
-  if (observed_output_representation_.is_more_general_than(rep)) {
-    rep = observed_output_representation_;
-  }
   for (int i = 1; i <= 2; ++i) {
     Representation input_rep = observed_input_representation(i);
     if (input_rep.is_more_general_than(rep)) rep = input_rep;
   }
   // If any of the actual input representation is more general than what we
   // have so far but not Tagged, use that representation instead.
   Representation left_rep = left()->representation();
   Representation right_rep = right()->representation();
 
   if (left_rep.is_more_general_than(rep) &&
       left()->CheckFlag(kFlexibleRepresentation)) {
     rep = left_rep;
   }
   if (right_rep.is_more_general_than(rep) &&
       right()->CheckFlag(kFlexibleRepresentation)) {
     rep = right_rep;
   }
+  // Consider observed output representation, but ignore it if it's Double,
+  // this instruction is not a division, and all its uses are truncating
+  // to Integer32.
+  if (observed_output_representation_.is_more_general_than(rep)) {

[Sven Panne, 2013/04/22 13:52:29]

Simplifying this a bit and extracting a predicate makes this much more readable:

-----------------------------------------------
bool HBinaryoperation::IgnoreObservedOutputRepresentation(Representation rep) {
  return observed_output_representation_.IsDouble() &&
      rep.IsInteger32() &&
      !this->IsDiv() &&
      CheckUsesForFlag(kTruncatingToInt32);
}


In HBinaryOperation::RepresentationFromInputs:
...
  if (observed_output_representation_.is_more_general_than(rep) &&
      !IgnoreObservedOutputRepresentation(rep)) {
    rep = observed_output_representation_;
  }
...
-----------------------------------------------

[Jakob Kummerow, 2013/04/22 15:24:41]

Done.

+    bool ignore = false;
+    if (observed_output_representation_.IsDouble() &&
+        rep.IsInteger32() &&
+        // TODO(jkummerow): remove the Div blacklisting when the Div
+        // instruction has learned not to deopt when the remainder is
+        // non-zero but all uses are truncating.
+        !this->IsDiv()) {
+      ignore = CheckUsesForFlag(kTruncatingToInt32);
+    }
+    if (!ignore) rep = observed_output_representation_;
+  }
   return rep;
 }
 
 
 void HBinaryOperation::AssumeRepresentation(Representation r) {
   set_observed_input_representation(r, r);
   HValue::AssumeRepresentation(r);
 }
 
 
@@ skipping 1332 matching lines @@
 
 
 void HCheckFunction::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal