Simplify HUnaryMathOperation::Canonicalize.

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 1390 matching lines @@
 void HChange::PrintDataTo(StringStream* stream) {
   HUnaryOperation::PrintDataTo(stream);
   stream->Add(" %s to %s", from().Mnemonic(), to().Mnemonic());
 
   if (CanTruncateToInt32()) stream->Add(" truncating-int32");
   if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
   if (CheckFlag(kAllowUndefinedAsNaN)) stream->Add(" allow-undefined-as-nan");
 }
 
 
-static HValue* SimplifiedDividendForMathFloorOfDiv(HValue* dividend) {
+HValue* HUnaryMathOperation::SimplifiedDividendForMathFloorOfDiv(HDiv* hdiv) {
+  HValue* dividend = hdiv->left();
   // A value with an integer representation does not need to be transformed.
-  if (dividend->representation().IsInteger32()) {
-    return dividend;
+  if (dividend->representation().IsInteger32()) return dividend;
+  // A change from an integer32 can be replaced by the integer32 value.
+  if (dividend->IsChange() && HChange::cast(dividend)->from().IsInteger32()) {
+    return HChange::cast(dividend)->value();
   }
-  // A change from an integer32 can be replaced by the integer32 value.
-  if (dividend->IsChange() &&
-      HChange::cast(dividend)->from().IsInteger32()) {
-    return HChange::cast(dividend)->value();
+  if (hdiv->observed_input_representation(1).IsSmiOrInteger32()) {
+    return Prepend(new(block()->zone()) HChange(
+        dividend, Representation::Integer32(), false, false));
   }
   return NULL;
 }
 
+
+HValue* HUnaryMathOperation::SimplifiedDivisorForMathFloorOfDiv(HDiv* hdiv) {
+  HValue* divisor = hdiv->right();
+  if (divisor->IsInteger32Constant()) {
+    return Prepend(HConstant::cast(divisor)->CopyToRepresentation(
+        Representation::Integer32(), divisor->block()->zone()));
+  }
+  // A value with an integer representation does not need to be transformed.
+  if (divisor->representation().IsInteger32()) return divisor;
+  // A change from an integer32 can be replaced by the integer32 value.
+  if (divisor->IsChange() && HChange::cast(divisor)->from().IsInteger32()) {
+    return HChange::cast(divisor)->value();
+  }
+  if (hdiv->observed_input_representation(2).IsSmiOrInteger32()) {
+    return Prepend(new(block()->zone()) HChange(
+        divisor, Representation::Integer32(), false, false));
+  }
+  return NULL;
+}
+
 
 HValue* HUnaryMathOperation::Canonicalize() {
   if (op() == kMathRound || op() == kMathFloor) {
     HValue* val = value();
     if (val->IsChange()) val = HChange::cast(val)->value();
-
-    // If the input is smi or integer32 then we replace the instruction with its
-    // input.
     if (val->representation().IsSmiOrInteger32()) {
-      if (!val->representation().Equals(representation())) {
-        HChange* result = new(block()->zone()) HChange(
-            val, representation(), false, false);
-        result->InsertBefore(this);
-        return result;
-      }
-      return val;
+      if (val->representation().Equals(representation())) return val;
+      return Prepend(new(block()->zone()) HChange(
+          val, representation(), false, false));
     }
   }
-
-  if (op() == kMathFloor) {
-    HValue* val = value();
-    if (val->IsDiv() && (val->UseCount() == 1)) {
-      HDiv* hdiv = HDiv::cast(val);
-      HValue* left = hdiv->left();
-      HValue* right = hdiv->right();
-      // Try to simplify left and right values of the division.
-      HValue* new_left = SimplifiedDividendForMathFloorOfDiv(left);
-      if (new_left == NULL &&
-          hdiv->observed_input_representation(1).IsSmiOrInteger32()) {
-        new_left = new(block()->zone()) HChange(
-            left, Representation::Integer32(), false, false);
-        HChange::cast(new_left)->InsertBefore(this);
-      }
-      HValue* new_right =
-          LChunkBuilder::SimplifiedDivisorForMathFloorOfDiv(right);
-      if (new_right == NULL &&
-#if V8_TARGET_ARCH_ARM
-          CpuFeatures::IsSupported(SUDIV) &&
-#endif
-          hdiv->observed_input_representation(2).IsSmiOrInteger32()) {
-        new_right = new(block()->zone()) HChange(
-            right, Representation::Integer32(), false, false);
-        HChange::cast(new_right)->InsertBefore(this);
-      }
-
-      // Return if left or right are not optimizable.
-      if ((new_left == NULL) || (new_right == NULL)) return this;
-
-      // Insert the new values in the graph.
-      if (new_left->IsInstruction() &&
-          !HInstruction::cast(new_left)->IsLinked()) {
-        HInstruction::cast(new_left)->InsertBefore(this);
-      }
-      if (new_right->IsInstruction() &&
-          !HInstruction::cast(new_right)->IsLinked()) {
-        HInstruction::cast(new_right)->InsertBefore(this);
-      }
-      HMathFloorOfDiv* instr =
-          HMathFloorOfDiv::New(block()->zone(), context(), new_left, new_right);
-      instr->InsertBefore(this);
-      return instr;
-    }
+  if (op() == kMathFloor && value()->IsDiv() && value()->UseCount() == 1) {
+    HDiv* hdiv = HDiv::cast(value());
+    HValue* left = SimplifiedDividendForMathFloorOfDiv(hdiv);

[Benedikt Meurer, 2014/01/24 12:33:21]

Can we please inline the SimplifiedDividend... and SimplifiedDivisor... methods
here? That'd greatly increase readability, since you no longer need to jump
between use and definition to understand what's happening here, and this is the
only call site anyway.

[Sven Panne, 2014/01/24 14:02:05]

Done.

+    if (left == NULL) return this;
+    HValue* right = SimplifiedDivisorForMathFloorOfDiv(hdiv);
+    if (right == NULL) return this;
+    return Prepend(HMathFloorOfDiv::New(
+        block()->zone(), context(), left, right));
   }
   return this;
 }
 
 
 HValue* HCheckInstanceType::Canonicalize() {
   if (check_ == IS_STRING && value()->type().IsString()) {
     return value();
   }
 
@@ skipping 1723 matching lines @@
                                 names_cache->map());
         HInstruction* index = HLoadKeyed::New(
             block()->graph()->zone(),
             block()->graph()->GetInvalidContext(),
             index_cache,
             key_load->key(),
             key_load->key(),
             key_load->elements_kind());
         map_check->InsertBefore(this);
         index->InsertBefore(this);
-        HLoadFieldByIndex* load = new(block()->zone()) HLoadFieldByIndex(
-            object(), index);
-        load->InsertBefore(this);
-        return load;
+        return Prepend(new(block()->zone()) HLoadFieldByIndex(
+            object(), index));
       }
     }
   }
 
   return this;
 }
 
 
 void HStoreNamedGeneric::PrintDataTo(StringStream* stream) {
   object()->PrintNameTo(stream);
@@ skipping 1196 matching lines @@
       break;
     case kExternalMemory:
       stream->Add("[external-memory]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal