[Turbofan] Add the concept of aliasing to RegisterConfiguration.

src/compiler/instruction.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/state-values-utils.h"
 
@@ skipping 43 matching lines @@
     case kUnorderedEqual:
     case kUnorderedNotEqual:
       return condition;
   }
   UNREACHABLE();
   return 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 {
   OFStream os(stdout);
   PrintableInstructionOperand wrapper;
   wrapper.register_configuration_ = config;
   wrapper.op_ = *this;
   os << wrapper << std::endl;
 }
 
@@ skipping 956 matching lines @@
   }
   for (int i = 0; i < code.InstructionBlockCount(); i++) {
     printable.sequence_->PrintBlock(printable.register_configuration_, i);
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8