[Turbofan] Add the concept of aliasing to RegisterConfiguration.

src/compiler/instruction.cc

Index: src/compiler/instruction.cc
diff --git a/src/compiler/instruction.cc b/src/compiler/instruction.cc
index 8f12efe7cb11458e29915df89aff3559e86187b1..ad00b7bc314105521435aa483899d918fc6c0ed7 100644
--- a/src/compiler/instruction.cc
+++ b/src/compiler/instruction.cc
@@ -61,8 +61,16 @@ FlagsCondition CommuteFlagsCondition(FlagsCondition condition) {
 
 bool InstructionOperand::InterferesWith(const InstructionOperand& that) const {
   if (!IsFPRegister() || !that.IsFPRegister()) return EqualsCanonicalized(that);
-  return LocationOperand::cast(this)->register_code() ==
-         LocationOperand::cast(that).register_code();
+
+  const LocationOperand& loc1 = *LocationOperand::cast(this);

[Mircea Trofin, 2016/06/22 06:07:34]

I'd move this method to LocationOperand and change the type of "that", too,
accordingly

[bbudge, 2016/06/22 20:16:03]

I agree it doesn't feel natural for this to be on InstructionOperand.

However, if this is moved to LocationOperand, then the two call sites have to be
modified to test for IsLocation or IsFPRegister on both operands (calling
EqualsCanonicalized on failure). We would still have to test in the method that
both operands are FP regs and call EqualsCanonicalized there as well on failure.
It's a bit more code and more testing at runtime.

WDYT?

+  const LocationOperand& loc2 = LocationOperand::cast(that);
+  const RegisterConfiguration* config =
+      RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN);

[Mircea Trofin, 2016/06/22 06:07:34]

Why force the configuration to TURBOFAN? How do unittests pass?

[bbudge, 2016/06/22 20:16:04]

We want the global register configuration for Turbofan here. It knows about the
actual registers and aliasing for the target platform.

The unit tests create their own test instances of RegisterConfiguration (they
don't test the global instances for Turbofan or Crankshaft, though such tests
are possible.)

[Mircea Trofin, 2016/06/22 21:37:37]

Not super sure I understand. Are you saying that aliasing is only a Turbofan
concept? If so, then should we just check if we're running under a turbofan
config?

[bbudge, 2016/06/22 21:51:13]

Outside of tests we should use either the Turbofan or Crankshaft configs. They
are currently identical, except for the number of aliased double registers. I
use the Turbofan config because this is in src/compiler.

+  if (config->fp_aliasing_kind() != RegisterConfiguration::COMBINE)
+    return loc1.register_code() == loc2.register_code();
+
+  return config->AreAliases(loc1.representation(), loc1.register_code(),
+                            loc2.representation(), loc2.register_code());
 }
 
 void InstructionOperand::Print(const RegisterConfiguration* config) const {