ARM64: Generate optimized code for Math.floor and Math.round with double outputs.

src/hydrogen-instructions.cc

Index: src/hydrogen-instructions.cc
diff --git a/src/hydrogen-instructions.cc b/src/hydrogen-instructions.cc
index c56f5dc36f8cce87074c070cf4486746d1ad6272..5da613f591e1956bf1167a4a7add99a3d59a0fe4 100644
--- a/src/hydrogen-instructions.cc
+++ b/src/hydrogen-instructions.cc
@@ -3721,6 +3721,12 @@ HType HChange::CalculateInferredType() {
 
 
 Representation HUnaryMathOperation::RepresentationFromInputs() {
+  if (SupportsFlexibleFloorAndRound() &&
+      (op_ == kMathFloor || op_ == kMathRound)) {
+    // Floor and Round always take a double input. The integral result can be
+    // used as an integer or a double. Infer the representation from the uses.
+    return Representation::None();
+  }
   Representation rep = representation();
   // If any of the actual input representation is more general than what we
   // have so far but not Tagged, use that representation instead.
@@ -4189,6 +4195,41 @@ HInstruction* HUnaryMathOperation::New(
 }
 
 
+Representation HUnaryMathOperation::RepresentationFromUses() {
+  if (op_ != kMathFloor && op_ != kMathRound) {
+    return HValue::RepresentationFromUses();
+  }
+
+  // The instruction can have an int32 or double output. Prefer a double
+  // representation if there are double uses.
+  bool has_double_use = false;
+
+  for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
+    HValue* use = it.value();
+    Representation rep = use->RequiredInputRepresentation(it.index());
+    bool rep_required = !rep.IsNone();
+    if (!rep_required) {

[Jakob Kummerow, 2014/04/25 14:12:03]

I'm not sure I like the way you're prioritizing required over observed
representations. If any of the uses (ideally, including transitive uses through
Phis, but that's clearly outside the scope of this CL) has observed doubles,
that should always be enough of a reason to choose double representation.

Example:
function f(x) { return Math.round(x) + "."; }
f(0x80000000);
f(0x80000000);
%OptimizeFunctionOnNextCall(f);
f(0x80000000);

This will deopt with the current patch, because the addition requires tagged
inputs, so the Round ignores it and chooses int32 representation. If you honor
the observed double feedback, you can avoid the deopt.
I think you'll just have to look at both required and observed representations.

[Alexandre Rames, 2014/04/25 16:05:26]

Removed consideration of the required representation.

On 2014/04/25 14:12:03, Jakob wrote:

[Jakob Kummerow, 2014/04/28 13:53:32]

Any reason you're not looking at both required and observed representations as I
suggested? If the only use is e.g. another unary math function (which requires
double inputs and, being a call, doesn't have any observed representation), it
would be nice to avoid deopts too. (If in my previous example you use "function
f(x) { return Math.log(Math.round(x)); }" that should exhibit what I mean.)

+      rep = use->observed_input_representation(it.index());
+    }
+    if (FLAG_trace_representation && !rep.IsNone()) {
+      PrintF("#%d %s is %s by #%d %s as %s%s\n",
+             id(), Mnemonic(),
+             rep_required ? "required" : "used",
+             use->id(), use->Mnemonic(), rep.Mnemonic(),
+             (use->CheckFlag(kTruncatingToInt32) ? "-trunc" : ""));
+    }
+    if (rep.IsDouble()) {
+      has_double_use = true;
+      if (!FLAG_trace_representation) {
+       break;

[Jakob Kummerow, 2014/04/25 14:12:03]

nit: indentation. Also, a comment would be nice (e.g. "Having seen one double
use is enough."), because changing control flow based on a tracing flag looks
quite surprising at first.

[Alexandre Rames, 2014/04/25 16:05:26]

Done.

+      }
+    }
+  }
+  return has_double_use ? Representation::Double()
+                        : Representation::Integer32();
+}
+
+
 HInstruction* HPower::New(Zone* zone,
                           HValue* context,
                           HValue* left,