[TwoAddressInstruction] Handle pointer compare sunk past statepoint.

[dantrushin]

Summary

CodeGenPrepare pass can sink pointer comparison across statepoint
to the point of use (see comment in IR/SafepointIRVerifier.cpp)
Due to specifics of statepoints, it is still legal to have tied
def and use rewritten to the same register in TwoAddress pass.
However, properly updating LiveIntervals and LiveVariables becomes
complicated. For simplicity, let's fall back to generic handling of
tied registers when we detect such case.

[dantrushin]

Rebase on top of precommitted test

[thakis]

The precommitted test breaks tests on mac: http://45.33.8.238/macm1/42841/step_11.txt

Please take a look and revert for now if it takes a while to fix. (Looks like the check looks for "Assertion ... failed" while the mac runtime apparently prints "Assertion failed: ...")

[dyung]

The precommitted test also appears to break on Windows: https://lab.llvm.org/buildbot/#/builders/216/builds/8547

[thakis]

reverted the test in 89aaae57eacf77a6902ef8d4af5c92a3d6c642c2 for now

[dantrushin]

Rebase on top of relanded test.
Added TODO about recomputation of live range/liveness instead of bailing out.

[skatkov]

lgtm as correctness fix. It would b good still to find a way to recompute analysis and revert this back.

llvm/lib/CodeGen/TwoAddressInstructionPass.cpp

for (auto &TO : TiedOperands) {
     MachineOperand &DstMO = MI->getOperand(DstIdx);
     Register RegA = DstMO.getReg();
 
     assert(RegB == MI->getOperand(SrcIdx).getReg());
 
     if (RegA == RegB)
       continue;
 
+    // CodeGenPrepare can sink pointer compare past statepoint, which
+    // breaks assumption that statepoint kills tied-use register when
+    // in SSA form (see note in IR/SafepointIRVerifier.cpp). Fall back
+    // to generic tied register handling to avoid assertion failures.
+    // TODO: Recompute LIS/LV information for new range here.
+    if (LIS) {
+      const auto &UseLI = LIS->getInterval(RegB);
+      const auto &DefLI = LIS->getInterval(RegA);
+      if (DefLI.overlaps(UseLI)) {
+        LLVM_DEBUG(dbgs() << "LIS: " << printReg(RegB, TRI, 0)
+                          << " UseLI overlaps with DefLI\n");
+        NeedCopy = true;
+        continue;
+      }
+    } else if (LV && LV->getVarInfo(RegB).findKill(MI->getParent()) != MI) {
+      // Note that MachineOperand::isKill does not work here, because it
+      // is set only on first register use in instruction and for statepoint
+      // tied-use register will usually be found in preceeding deopt bundle.
+      LLVM_DEBUG(dbgs() << "LV: " << printReg(RegB, TRI, 0)
+                        << " not killed by statepoint\n");
+      NeedCopy = true;
+      continue;
+    }
+
     MRI->replaceRegWith(RegA, RegB);
 
     if (LIS) {
       VNInfo::Allocator &A = LIS->getVNInfoAllocator();
       LiveInterval &LI = LIS->getInterval(RegB);
-      for (auto &S : LIS->getInterval(RegA)) {
-        VNInfo *VNI = LI.getNextValue(S.start, A);
+      LiveInterval &Other = LIS->getInterval(RegA);
+      SmallVector<VNInfo *> NewVNIs;
+      for (const VNInfo *VNI : Other.valnos) {
+        assert(VNI->id == NewVNIs.size() && "assumed");
+        NewVNIs.push_back(LI.createValueCopy(VNI, A));
+      }
+      for (auto &S : Other) {
+        VNInfo *VNI = NewVNIs[S.valno->id];
         LiveRange::Segment NewSeg(S.start, S.end, VNI);
         LI.addSegment(NewSeg);
       }
       LIS->removeInterval(RegA);
     }
 
     if (LV) {
       if (MI->getOperand(SrcIdx).isKill())

llvm/test/CodeGen/X86/statepoint-cmp-sunk-past-statepoint.ll

-; RUN: not --crash llc -max-registers-for-gc-values=256 -verify-machineinstrs -stop-after twoaddressinstruction < %s 2>&1 | FileCheck --check-prefixes CHECK-ERROR-LV %s
-; RUN: not --crash llc -max-registers-for-gc-values=256 -verify-machineinstrs -stop-after twoaddressinstruction -early-live-intervals < %s 2>&1  | FileCheck --check-prefixes CHECK-ERROR-LIS %s
-; REQUIRES: asserts
-
-; CHECK-ERROR-LV:  Bad machine code: Virtual register killed in block, but needed live out.
-; CHECK-ERROR-LV:  function:    test
-; CHECK-ERROR-LV:  basic block: %bb.0
-
-; CHECK-ERROR-LIS: Found multiple kills of a register in a basic block
+; RUN: llc -max-registers-for-gc-values=256 -verify-machineinstrs -stop-after twoaddressinstruction < %s | FileCheck --check-prefixes CHECK,CHECK-LV %s
+; RUN: llc -max-registers-for-gc-values=256 -verify-machineinstrs -stop-after twoaddressinstruction -early-live-intervals < %s | FileCheck --check-prefixes CHECK,CHECK-LIS %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128-ni:1-p2:32:8:8:32-ni:2"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @foo() gc "statepoint-example"
 declare void @bar(i8 addrspace(1)*) gc "statepoint-example"
 
 declare i32* @fake_personality_function()
 
 ; Simplest possible test demonstrating the problem
 
 ; CHECK-LABEL: name: test
 ; CHECK:  bb.0
 ; CHECK-LV:     %0:gr64 = COPY killed $rdi
 ; CHECK-LIS:    %0:gr64 = COPY $rdi
-; CHECK:        %0:gr64 = STATEPOINT 2, 5, 0, undef %2:gr64, 2, 0, 2, 0, 2, 0, 2, 1, %0(tied-def 0), 2, 0, 2, 1, 0, 0
+; CHECK:        %1:gr64 = COPY %0
+; CHECK:        %1:gr64 = STATEPOINT 2, 5, 0, undef %2:gr64, 2, 0, 2, 0, 2, 0, 2, 1, %1(tied-def 0), 2, 0, 2, 1, 0, 0
 ; CHECK-LV:     TEST64rr killed %0, %0, implicit-def $eflags
 ; CHECK-LIS:    TEST64rr %0, %0, implicit-def $eflags
 ; CHECK:        JCC_1 %bb.2, 4, implicit killed $eflags
 ; CHECK:        JMP_1 %bb.1
 ; CHECK:      bb.1
-; CHECK-LV:     $rdi = COPY killed %0
-; CHECK-LV:     STATEPOINT 2, 5, 1, undef %3:gr64, $rdi, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0
-; CHECK-LIS:    $rdi = COPY killed %0
+; CHECK-LV:     $rdi = COPY killed %1
+; CHECK-LV:     STATEPOINT 2, 5, 1, undef %3:gr64, killed $rdi, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0
+; CHECK-LIS:    $rdi = COPY %1
 ; CHECK-LIS:    STATEPOINT 2, 5, 1, undef %3:gr64, $rdi, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0
 ; CHECK:        RET 0
 ; CHECK:      bb.2
 ; CHECK:        RET 0
 define void @test(i8 addrspace(1)* %a)  gc "statepoint-example" {
 entry:
   %not7 = icmp eq i8 addrspace(1)* %a, null
   %statepoint_token1745 = call token (i64, i32, void ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2, i32 5, void ()* nonnull elementtype(void ()) @foo, i32 0, i32 0, i32 0, i32 0) [ "deopt"(), "gc-live"(i8 addrspace(1)* %a) ]
   br i1 %not7, label %zero, label %not_zero
 
 not_zero:
   %a.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token %statepoint_token1745, i32 0, i32 0) ; (%a, %a)
   %statepoint_token1752 = call token (i64, i32, void (i8 addrspace(1)*)*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i8f(i64 2, i32 5, void (i8 addrspace(1)*)* nonnull elementtype(void (i8 addrspace(1)*)) @bar, i32 1, i32 0, i8 addrspace(1)* %a.relocated, i32 0, i32 0) [ "deopt"(), "gc-live"() ]
   ret void
 
 zero:
   ret void
 }
 
 ; A bit more complex test, where both registers are used in same successor BB
 
 ; CHECK-LABEL: name: test2
 ; CHECK:  bb.2
 ; CHECK:        %1:gr64 = STATEPOINT 2882400000, 0, 0, undef %11:gr64, 2, 0, 2, 0, 2, 0, 2, 1, %1(tied-def 0), 2, 0, 2, 1, 0, 0, csr_64
-; CHECK:        %1:gr64 = STATEPOINT 2882400000, 0, 0, undef %13:gr64, 2, 0, 2, 0, 2, 0, 2, 1, %1(tied-def 0), 2, 0, 2, 1, 0, 0, csr_64
+; CHECK:        %10:gr64 = COPY %1
+; CHECK:        %10:gr64 = STATEPOINT 2882400000, 0, 0, undef %13:gr64, 2, 0, 2, 0, 2, 0, 2, 1, %10(tied-def 0), 2, 0, 2, 1, 0, 0, csr_64
 ; CHECK:        JMP_1 %bb.3
 ; CHECK:      bb.3
 ; CHECK:        %18:gr8 = COPY %17.sub_8bit
 ; CHECK-LV:     TEST8rr killed %18, %18, implicit-def $eflags
 ; CHECK-LIS:    TEST8rr %18, %18, implicit-def $eflags
 ; CHECK:        JCC_1 %bb.5, 5, implicit killed $eflags
 ; CHECK:        JMP_1 %bb.4
 ; CHECK:      bb.4
 ; CHECK:      bb.5
-; CHECK:        %4:gr64 = LEA64r %1, 1, $noreg, 8, $noreg
-; CHECK-LV:     %3:gr64 = COPY killed %1
-; CHECK-LIS:    %3:gr64 = COPY killed %1
+; CHECK:        %4:gr64 = LEA64r %10, 1, $noreg, 8, $noreg
+; CHECK-LV:     %3:gr64 = COPY killed %10
+; CHECK-LIS:    %3:gr64 = COPY %10
 ; CHECK-LV:     TEST64rr killed %1, %1, implicit-def $eflags
 ; CHECK:        JCC_1 %bb.1, 5, implicit killed $eflags
 ; CHECK:        JMP_1 %bb.6
 define void @test2(i8 addrspace(1)* %this, i32 %0, i32 addrspace(1)* %p0, i8 addrspace(1)* %p1) gc "statepoint-example" personality i32* ()* @fake_personality_function {
 preheader:
   br label %loop.head
 
 loop.head: