Use integer division in a certain case.

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 1084 matching lines @@
 
 
 Range* HValue::InferRange(Zone* zone) {
   // Untagged integer32 cannot be -0, all other representations can.
   Range* result = new(zone) Range();
   result->set_can_be_minus_zero(!representation().IsInteger32());
   return result;
 }
 
 
+#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X64)
+
+// Return an integer value or NULL, which may involve skipping over a
+// representation change
+static HValue* SimplifiedValueForIntDiv(HValue* value) {
+  if (value->representation().IsInteger32()) {
+    return value;
+  } else if (value->IsConstant() &&
+      HConstant::cast(value)->HasInteger32Value()) {
+    return value;
+  } else if (value->IsChange() &&
+      HChange::cast(value)->from().IsInteger32()) {
+    return HChange::cast(value)->value();
+  }
+  return NULL;
+}
+
+
+// Insert an integer constant into the graph when given a non-integer constant
+static HValue* EnsureIntegerConstantForIntDiv(HValue* value,
+                                              HInstruction* insertBefore) {
+  if (value->IsConstant() && !value->representation().IsInteger32()) {
+    ASSERT(HConstant::cast(value)->HasInteger32Value());
+    HConstant* constant = HConstant::cast(value)->CopyToRepresentation(
+      Representation::Integer32(), insertBefore->block()->zone());
+    constant->InsertBefore(insertBefore);
+    return constant;
+  }
+  return value;
+}
+
+
+// Try to replace the division of a non-negative integer by a positive integer
+// that is then truncated to an integer with an integer division instruction.
+// This gives a 2x speedup over using double division. Return NULL on failure.
+static HDiv* MaybeConvertToIntDiv(HChange* change, Zone* zone) {
+  if (change->value()->IsDiv() &&
+      HDiv::cast(change->value())->UseCount() == 1 &&
+      change->from().IsDouble() &&
+      change->to().IsInteger32() &&
+      change->CheckFlag(HValue::kTruncatingToInt32)) {
+    HDiv* div = HDiv::cast(change->value());
+    HValue* left = div->left();
+    HValue* right = div->right();
+    HValue* new_left = SimplifiedValueForIntDiv(left);
+    HValue* new_right = SimplifiedValueForIntDiv(right);
+
+    // Only apply this optimization if we know it won't hit any special cases
+    // that would otherwise cause a deopt in the representation change
+    if (new_left != NULL && new_right != NULL &&
+        new_left->range()->lower() >= 0 &&
+        new_right->range()->lower() > 0) {
+      // Change non-integer constants to integer constants
+      new_left = EnsureIntegerConstantForIntDiv(new_left, div);
+      new_right = EnsureIntegerConstantForIntDiv(new_right, div);
+      ASSERT(new_left->representation().IsInteger32());
+      ASSERT(new_right->representation().IsInteger32());
+
+      // Replace this representation change with an integer division
+      HDiv* new_div = new(div->block()->zone()) HDiv(div->context(),
+        new_left, new_right);
+      new_div->AssumeRepresentation(Representation::Integer32());
+      new_div->InsertBefore(div);
+      change->DeleteAndReplaceWith(new_div);
+
+      // Delete unused instructions
+      div->DeleteAndReplaceWith(NULL);
+      if (left->HasNoUses()) left->DeleteAndReplaceWith(NULL);
+      if (right->HasNoUses()) right->DeleteAndReplaceWith(NULL);
+
+      // Tell codegen not to emit code to check for a non-zero remainder.
+      // Codegen can't use CheckUsesForFlag(kTruncatingToInt32) because
+      // that flag is on the HChange instruction which is now deleted.
+      new_div->SetFlag(HValue::kWillTruncateToInt32);
+
+      // Make sure all new values have ranges
+      if (!new_left->HasRange()) new_left->ComputeInitialRange(zone);
+      if (!new_right->HasRange()) new_right->ComputeInitialRange(zone);
+      new_div->ComputeInitialRange(zone);
+      return new_div;
+    }
+  }
+  return NULL;
+}
+
+#endif
+
+
 Range* HChange::InferRange(Zone* zone) {
+#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X64)
+  HDiv* div = MaybeConvertToIntDiv(this, zone);
+  if (div != NULL) {
+    return div->range();
+  }
+#endif
+
   Range* input_range = value()->range();
   if (from().IsInteger32() &&
       to().IsTagged() &&
       input_range != NULL && input_range->IsInSmiRange()) {
     set_type(HType::Smi());
   }
   Range* result = (input_range != NULL)
       ? input_range->Copy(zone)
       : HValue::InferRange(zone);
   if (to().IsInteger32()) result->set_can_be_minus_zero(false);
@@ skipping 86 matching lines @@
     if (left()->range()->CanBeMinusZero()) {
       result->set_can_be_minus_zero(true);
     }
 
     if (left()->range()->CanBeZero() && right()->range()->CanBeNegative()) {
       result->set_can_be_minus_zero(true);
     }
 
     if (right()->range()->Includes(-1) && left()->range()->Includes(kMinInt)) {
       SetFlag(HValue::kCanOverflow);
+    } else {
+      ClearFlag(HValue::kCanOverflow);
     }
 
     if (!right()->range()->CanBeZero()) {
       ClearFlag(HValue::kCanBeDivByZero);
     }
+
+    // An exact range can be inferred for division with integer operands
+    if (left()->representation().IsInteger32() &&
+        right()->representation().IsInteger32() &&
+        left()->range()->lower() >= 0 &&
+        right()->range()->lower() > 0) {
+      Range limits(left()->range()->lower() / right()->range()->upper(),
+        left()->range()->upper() / right()->range()->lower());
+      result->Intersect(&limits);
+    }
     return result;
   } else {
     return HValue::InferRange(zone);
   }
 }
 
 
 Range* HMod::InferRange(Zone* zone) {
   if (representation().IsInteger32()) {
     Range* a = left()->range();
@@ skipping 1357 matching lines @@
 
 
 void HCheckPrototypeMaps::Verify() {
   HInstruction::Verify();
   ASSERT(HasNoUses());
 }
 
 #endif
 
 } }  // namespace v8::internal