[TableGen] Support tied operands that are both source operands

[bleibig]

Summary

Currently tied operands have a restriction that one is a source and
the other is a dest. This patch aims to relax that restriction, so
that two source operands can be tied.

The purpose is enable the kind of tablegen definition described here:
http://lists.llvm.org/pipermail/llvm-dev/2019-April/131663.html
Where two source operands from different register files must have the
same register number, as the bits in the encoding specify the register
number for two different operands (other bits specify the register
files used). Even though the first operand is called "dst", it must be
treated as a source operand as it holds an address that the
instruction writes to (like a store instruction), and thus must be
loaded appropriately before the instruction is generated.

Part of these changes remove the ConstraintChecking{4,5}.td tests as
they check for an error that shouldn't be occuring anymore, tests 6
and 7 have been shifted down to replace them.

[bleibig]

I'm not sure why the checks were initially added, whether it is because the tied operand system is designed only for use and def tied operands and won't work in any other way without major changes, or just because there hasn't been a use case yet for two tied source operands. Either way, I feel the changes I have so far may be insufficient to solve this, so any feedback for further changes would be greatly appreciated.

[bjope]

I don't really understand the problem situation. Why are you having two source operands if they need to be the same? Can't you ensure that by only having one source operand?

I mean, the main reason for having tied operands today is to be able to model two address instructions while having SSA form. When we must have different virtual registers as src and dst. SSA deconstruction, to be more specific the TwoAddressInstructionPass, will tie the register together to get the single virtual register when SSA form isn't needed any longer. In your case, you only deal with source operands, so there is no problem with SSA form. You can either model your instructions as having a single source, or just use the same virtual register in multiple source operands.

Got a feeling that you are trying to misuse the tied-operand concept here somehow.

I'm also worried about that there is not test case for the changes in the backend (TwoAddressIntructionPass and how this impacts the rest of codegen - can't see anything that verifies that this patch actually ties the virtual registers together).

[bleibig]

Following up on this, I've realized that these changes might not be necessary for what I am trying to do, as it seems like I can make things work without using the constraint at all. This can be de-prioritized for the time being.

[bleibig]

Closing as I am not working on this anymore.

llvm/lib/CodeGen/MachineInstr.cpp

 //===- lib/CodeGen/MachineInstr.cpp ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 /// TiedMax:        Tied to an operand >= TiedMax-1.
 ///
 /// The tied def must be one of the first TiedMax operands on a normal
 /// instruction. INLINEASM instructions allow more tied defs.
 ///
 void MachineInstr::tieOperands(unsigned DefIdx, unsigned UseIdx) {
   MachineOperand &DefMO = getOperand(DefIdx);
   MachineOperand &UseMO = getOperand(UseIdx);
-  assert(DefMO.isDef() && "DefIdx must be a def operand");
   assert(UseMO.isUse() && "UseIdx must be a use operand");
   assert(!DefMO.isTied() && "Def is already tied to another use");
   assert(!UseMO.isTied() && "Use is already tied to another def");
 
   if (DefIdx < TiedMax)
     UseMO.TiedTo = DefIdx + 1;
   else {
     // Inline asm can use the group descriptors to find tied operands, but on

llvm/lib/CodeGen/TwoAddressInstructionPass.cpp

 //===- TwoAddressInstructionPass.cpp - Two-Address instruction pass -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (unsigned SrcIdx = 0; SrcIdx < NumOps; ++SrcIdx) {
     AnyOps = true;
     MachineOperand &SrcMO = MI->getOperand(SrcIdx);
     MachineOperand &DstMO = MI->getOperand(DstIdx);
     Register SrcReg = SrcMO.getReg();
     Register DstReg = DstMO.getReg();
     // Tied constraint already satisfied?
     if (SrcReg == DstReg)
       continue;
+    // Ignore tied operands where both are source operands.
+    if (!DstMO.isDef()) {
+      continue;
+    }
 
     assert(SrcReg && SrcMO.isUse() && "two address instruction invalid");
 
     // Deal with undef uses immediately - simply rewrite the src operand.
     if (SrcMO.isUndef() && !DstMO.getSubReg()) {
       // Constrain the DstReg register class if required.
       if (Register::isVirtualRegister(DstReg))
         if (const TargetRegisterClass *RC = TII->getRegClass(MCID, SrcIdx,

llvm/test/TableGen/ConstraintChecking4.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Output operands '$dest1' and '$dest2' of 'Foo' cannot be tied!
-def Foo : TestInstructionWithConstraints<"$dest1 = $dest2">;
+// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$dest1' of 'Foo' cannot have multiple operands tied to it!
+def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest1 = $src2">;

llvm/test/TableGen/ConstraintChecking5.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Input operands '$src1' and '$src2' of 'Foo' cannot be tied!
-def Foo : TestInstructionWithConstraints<"$src1 = $src2">;
+// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$src1' of 'Foo' cannot have multiple constraints!
+def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest2 = $src1">;

llvm/test/TableGen/ConstraintChecking6.td

-// RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
-
-include "ConstraintChecking.inc"
-
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$dest1' of 'Foo' cannot have multiple operands tied to it!
-def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest1 = $src2">;

llvm/test/TableGen/ConstraintChecking7.td

-// RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
-
-include "ConstraintChecking.inc"
-
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$src1' of 'Foo' cannot have multiple constraints!
-def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest2 = $src1">;

llvm/utils/TableGen/CodeGenInstruction.cpp

 //===- CodeGenInstruction.cpp - CodeGen Instruction Class Wrapper ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
static void ParseConstraint(const std::string &CStr, CGIOperandList &Ops,
   // Sort the operands into order, which should put the output one
   // first. But keep the original order, for use in diagnostics.
   bool FirstIsDest = (LHSOp < RHSOp);
   std::pair<unsigned,unsigned> DestOp = (FirstIsDest ? LHSOp : RHSOp);
   StringRef DestOpName = (FirstIsDest ? LHSOpName : RHSOpName);
   std::pair<unsigned,unsigned> SrcOp = (FirstIsDest ? RHSOp : LHSOp);
   StringRef SrcOpName = (FirstIsDest ? RHSOpName : LHSOpName);
 
-  // Ensure one operand is a def and the other is a use.
-  if (DestOp.first >= Ops.NumDefs)
-    PrintFatalError(
-      Rec->getLoc(), "Input operands '" + LHSOpName + "' and '" + RHSOpName +
-      "' of '" + Rec->getName() + "' cannot be tied!");
-  if (SrcOp.first < Ops.NumDefs)
-    PrintFatalError(
-      Rec->getLoc(), "Output operands '" + LHSOpName + "' and '" + RHSOpName +
-      "' of '" + Rec->getName() + "' cannot be tied!");
-
   // The constraint has to go on the operand with higher index, i.e.
   // the source one. Check there isn't another constraint there
   // already.
   if (!Ops[SrcOp.first].Constraints[SrcOp.second].isNone())
     PrintFatalError(
       Rec->getLoc(), "Operand '" + SrcOpName + "' of '" + Rec->getName() +
       "' cannot have multiple constraints!");