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

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 3703 matching lines @@
 }
 
 
 HType HChange::CalculateInferredType() {
   if (from().IsDouble() && to().IsTagged()) return HType::HeapNumber();
   return type();
 }
 
 
 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.
   Representation input_rep = value()->representation();
   if (!input_rep.IsTagged()) {
     rep = rep.generalize(input_rep);
   }
   return rep;
 }
 
@@ skipping 448 matching lines @@
       }
       default:
         UNREACHABLE();
         break;
     }
   } while (false);
   return new(zone) HUnaryMathOperation(context, value, op);
 }
 
 
+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,
                           HValue* right) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_left = HConstant::cast(left);
     HConstant* c_right = HConstant::cast(right);
     if (c_left->HasNumberValue() && c_right->HasNumberValue()) {
       double result = power_helper(c_left->DoubleValue(),
                                    c_right->DoubleValue());
@@ skipping 542 matching lines @@
       break;
     case kExternalMemory:
       stream->Add("[external-memory]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal