[AMDGPU] Ressociate patterns with sub to use SALU

[rampitec]

Looks reasonable.

[dstuttard]

This change appears to be causing an infinite loop for one of our shaders.

[foad]

Here's a test case for the infinite loop. Can you please fix or revert?

; RUN: llc -march=amdgcn -mcpu=gfx1030 < %s
define amdgpu_cs void @f(i32 inreg %arg, i32 %arg1) {
bb:
  %i = add i32 %arg1, %arg
  %i2 = sub i32 0, %i
  call void @llvm.amdgcn.raw.buffer.store.i32(i32 %i2, <4 x i32> zeroinitializer, i32 0, i32 0, i32 0)
  ret void
}
declare void @llvm.amdgcn.raw.buffer.store.i32(i32, <4 x i32>, i32, i32, i32 immarg)

[bcl5980]

limit the optimization to non-constant value to workaround dead loop.

[bcl5980]

I have already revert it on rG9356097206a17
Can someone help to review the new patch?

[bcl5980]

rebase the code

[rampitec]

Did you find what DAG transformation undoes this? It might be better to tweak that one instead.

[bcl5980]

In D148463#4281590, @rampitec wrote:

Did you find what DAG transformation undoes this? It might be better to tweak that one instead.

Yeah, that is what I do in D148710.

llvm/lib/Target/AMDGPU/SIISelLowering.h

SDValue performIntMed3ImmCombine(SelectionDAG &DAG, const SDLoc &SL,
                                    bool Signed) const;
   SDValue performMinMaxCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performFMed3Combine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performCvtPkRTZCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performExtractVectorEltCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performInsertVectorEltCombine(SDNode *N, DAGCombinerInfo &DCI) const;
 
   SDValue reassociateScalarOps(SDNode *N, SelectionDAG &DAG) const;
+  SDValue reassociateSub(SDNode *N, SelectionDAG &DAG) const;
   unsigned getFusedOpcode(const SelectionDAG &DAG,
                           const SDNode *N0, const SDNode *N1) const;
   SDValue tryFoldToMad64_32(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performAddCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performAddCarrySubCarryCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performSubCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performFAddCombine(SDNode *N, DAGCombinerInfo &DCI) const;
   SDValue performFSubCombine(SDNode *N, DAGCombinerInfo &DCI) const;

llvm/lib/Target/AMDGPU/SIISelLowering.cpp

SDValue SITargetLowering::reassociateScalarOps(SDNode *N,
   if (Op1->isDivergent())
     std::swap(Op1, Op2);
 
   SDLoc SL(N);
   SDValue Add1 = DAG.getNode(Opc, SL, VT, Op0, Op1);
   return DAG.getNode(Opc, SL, VT, Add1, Op2);
 }
 
+SDValue SITargetLowering::reassociateSub(SDNode *N, SelectionDAG &DAG) const {
+  EVT VT = N->getValueType(0);
+  if (VT != MVT::i32 && VT != MVT::i64)
+    return SDValue();
+
+  unsigned Opc = N->getOpcode();
+  SDValue Op0 = N->getOperand(0);
+  SDValue Op1 = N->getOperand(1);
+
+  if (!(Op0->isDivergent() ^ Op1->isDivergent()))
+    return SDValue();
+
+  // Actually we can optimize the case with constant, but it looks there are
+  // some patterns in DAGCombiner to revert the opt cause dead loop. So for now
+  // we disable this optimization for any op is constant.
+  if (isa<ConstantSDNode>(Op0) || isa<ConstantSDNode>(Op1))
+    return SDValue();
+
+  SDLoc SL(N);
+  if (Op1->isDivergent() && Op1->hasOneUse()) {
+    unsigned Op1Opc = Op1.getOpcode();
+    if (Op1Opc != ISD::ADD && Op1Opc != ISD::SUB)
+      return SDValue();
+
+    SDValue Op2 = Op1.getOperand(1);
+    Op1 = Op1.getOperand(0);
+    if (isa<ConstantSDNode>(Op1) || isa<ConstantSDNode>(Op2))
+      return SDValue();
+
+    if (Opc == ISD::ADD && Op1Opc == ISD::SUB) {
+      // s0 + (s1 - v0) --> (s0 + s1) - v0
+      if (!Op1->isDivergent() && Op2->isDivergent())
+        return DAG.getNode(ISD::SUB, SL, VT,
+                           DAG.getNode(ISD::ADD, SL, VT, Op0, Op1), Op2);
+      // s0 + (v0 - s1) --> (s0 - s1) + v0
+      if (Op1->isDivergent() && !Op2->isDivergent())
+        return DAG.getNode(ISD::ADD, SL, VT,
+                           DAG.getNode(ISD::SUB, SL, VT, Op0, Op2), Op1);
+    } else if (Opc == ISD::SUB) {
+      if (Op1Opc == ISD::SUB) {
+        // s0 - (s1 - v0) --> (s0 - s1) + v0
+        if (!Op1->isDivergent() && Op2->isDivergent())
+          return DAG.getNode(ISD::ADD, SL, VT,
+                             DAG.getNode(ISD::SUB, SL, VT, Op0, Op1), Op2);
+        // s0 - (v0 - s1) --> (s0 + s1) - v0
+        if (Op1->isDivergent() && !Op2->isDivergent())
+          return DAG.getNode(ISD::SUB, SL, VT,
+                             DAG.getNode(ISD::ADD, SL, VT, Op0, Op2), Op1);
+      } else if (Op1Opc == ISD::ADD) {
+        // s0 - (s1 + v0) --> (s0 - s1) - v0
+        if (Op1->isDivergent() ^ Op2->isDivergent()) {
+          if (Op1->isDivergent())
+            std::swap(Op1, Op2);
+          return DAG.getNode(ISD::SUB, SL, VT,
+                             DAG.getNode(ISD::SUB, SL, VT, Op0, Op1), Op2);
+        }
+      }
+    }
+  }
+
+  if (Op0->isDivergent() && Op0->hasOneUse()) {
+    unsigned Op0Opc = Op0.getOpcode();
+    if (Op0Opc != ISD::ADD && Op0Opc != ISD::SUB)
+      return SDValue();
+
+    SDValue Op2 = Op0.getOperand(1);
+    Op0 = Op0.getOperand(0);
+    if (isa<ConstantSDNode>(Op1) || isa<ConstantSDNode>(Op2))
+      return SDValue();
+
+    if (!Op0->isDivergent() && Op2->isDivergent()) {
+      if (Opc == ISD::SUB) {
+        // (s1 + v0) - s0 --> (s1 - s0) + v0
+        if (Op0Opc == ISD::ADD)
+          return DAG.getNode(ISD::ADD, SL, VT,
+                             DAG.getNode(ISD::SUB, SL, VT, Op0, Op1), Op2);
+
+        // (s1 - v0) - s0 --> (s1 - s0) - v0
+        if (Op0Opc == ISD::SUB)
+          return DAG.getNode(ISD::SUB, SL, VT,
+                             DAG.getNode(ISD::SUB, SL, VT, Op0, Op1), Op2);
+      } else if (Opc == ISD::ADD && Op0Opc == ISD::SUB) {
+        // (s1 - v0) + s0 --> (s0 + s1) - v0
+        return DAG.getNode(ISD::SUB, SL, VT,
+                           DAG.getNode(ISD::ADD, SL, VT, Op0, Op1), Op2);
+      }
+    }
+
+    if (Op0->isDivergent() && !Op2->isDivergent()) {
+      // (v0 - s1) + s0 --> (s0 - s1) + v0
+      if (Opc == ISD::ADD && Op0Opc == ISD::SUB)
+        return DAG.getNode(ISD::ADD, SL, VT,
+                           DAG.getNode(ISD::SUB, SL, VT, Op1, Op2), Op0);
+    }
+  }
+
+  return SDValue();
+}
+
 static SDValue getMad64_32(SelectionDAG &DAG, const SDLoc &SL,
                            EVT VT,
                            SDValue N0, SDValue N1, SDValue N2,
                            bool Signed) {
   unsigned MadOpc = Signed ? AMDGPUISD::MAD_I64_I32 : AMDGPUISD::MAD_U64_U32;
   SDVTList VTs = DAG.getVTList(MVT::i64, MVT::i1);
   SDValue Mad = DAG.getNode(MadOpc, SL, VTs, N0, N1, N2);
   return DAG.getNode(ISD::TRUNCATE, SL, VT, Mad);
if (LHS.getOpcode() == ISD::MUL || RHS.getOpcode() == ISD::MUL) {
 
     return SDValue();
   }
 
   if (SDValue V = reassociateScalarOps(N, DAG)) {
     return V;
   }
 
+  if (SDValue V = reassociateSub(N, DAG))
+    return V;
+
   if (VT != MVT::i32 || !DCI.isAfterLegalizeDAG())
     return SDValue();
 
   // add x, zext (setcc) => addcarry x, 0, setcc
   // add x, sext (setcc) => subcarry x, 0, setcc
   unsigned Opc = LHS.getOpcode();
   if (Opc == ISD::ZERO_EXTEND || Opc == ISD::SIGN_EXTEND ||
       Opc == ISD::ANY_EXTEND || Opc == ISD::ADDCARRY)
SDValue SITargetLowering::performAddCombine(SDNode *N,
   return SDValue();
 }
 
 SDValue SITargetLowering::performSubCombine(SDNode *N,
                                             DAGCombinerInfo &DCI) const {
   SelectionDAG &DAG = DCI.DAG;
   EVT VT = N->getValueType(0);
 
+  if (SDValue V = reassociateSub(N, DAG))
+    return V;
+
   if (VT != MVT::i32)
     return SDValue();
 
   SDLoc SL(N);
   SDValue LHS = N->getOperand(0);
   SDValue RHS = N->getOperand(1);
 
   // sub x, zext (setcc) => subcarry x, 0, setcc

llvm/test/CodeGen/AMDGPU/combine-cond-add-sub.ll

 ; GCN-NEXT:    v_mov_b32_e32 v3, 0
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
 ; GCN-NEXT:    s_mov_b64 s[4:5], s[0:1]
 ; GCN-NEXT:    buffer_load_dword v4, v[2:3], s[4:7], 0 addr64
 ; GCN-NEXT:    v_cmp_gt_u32_e32 vcc, v0, v1
 ; GCN-NEXT:    v_cndmask_b32_e64 v0, 0, 1, vcc
 ; GCN-NEXT:    s_waitcnt vmcnt(0)
 ; GCN-NEXT:    v_sub_i32_e32 v0, vcc, v0, v4
-; GCN-NEXT:    v_add_i32_e32 v0, vcc, s2, v0
-; GCN-NEXT:    v_subrev_i32_e32 v0, vcc, s3, v0
+; GCN-NEXT:    s_sub_i32 s0, s2, s3
+; GCN-NEXT:    v_add_i32_e32 v0, vcc, s0, v0
 ; GCN-NEXT:    buffer_store_dword v0, v[2:3], s[4:7], 0 addr64
 ; GCN-NEXT:    s_endpgm
 ;
 ; GFX9-LABEL: sub_zext_setcc_commute:
 ; GFX9:       ; %bb.0: ; %bb
 ; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
 ; GFX9-NEXT:    v_lshlrev_b32_e32 v2, 2, v0
 ; GFX9-NEXT:    v_cmp_gt_u32_e32 vcc, v0, v1
 ; GFX9-NEXT:    v_cndmask_b32_e64 v0, 0, 1, vcc
 ; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
 ; GFX9-NEXT:    global_load_dword v3, v2, s[0:1]
+; GFX9-NEXT:    s_sub_i32 s2, s2, s3
 ; GFX9-NEXT:    s_waitcnt vmcnt(0)
 ; GFX9-NEXT:    v_sub_u32_e32 v0, v0, v3
 ; GFX9-NEXT:    v_add_u32_e32 v0, s2, v0
-; GFX9-NEXT:    v_subrev_u32_e32 v0, s3, v0
 ; GFX9-NEXT:    global_store_dword v2, v0, s[0:1]
 ; GFX9-NEXT:    s_endpgm
 bb:
   %x = tail call i32 @llvm.amdgcn.workitem.id.x()
   %y = tail call i32 @llvm.amdgcn.workitem.id.y()
   %gep = getelementptr inbounds i32, ptr addrspace(1) %arg, i32 %x
   %v = load i32, ptr addrspace(1) %gep, align 4
   %cmp = icmp ugt i32 %x, %y

 ; GCN-NEXT:    v_mov_b32_e32 v3, 0
 ; GCN-NEXT:    s_waitcnt lgkmcnt(0)
 ; GCN-NEXT:    s_mov_b64 s[4:5], s[0:1]
 ; GCN-NEXT:    buffer_load_dword v4, v[2:3], s[4:7], 0 addr64
 ; GCN-NEXT:    v_cmp_gt_u32_e32 vcc, v0, v1
 ; GCN-NEXT:    v_cndmask_b32_e64 v0, 0, -1, vcc
 ; GCN-NEXT:    s_waitcnt vmcnt(0)
 ; GCN-NEXT:    v_sub_i32_e32 v0, vcc, v0, v4
-; GCN-NEXT:    v_add_i32_e32 v0, vcc, s2, v0
-; GCN-NEXT:    v_subrev_i32_e32 v0, vcc, s3, v0
+; GCN-NEXT:    s_sub_i32 s0, s2, s3
+; GCN-NEXT:    v_add_i32_e32 v0, vcc, s0, v0
 ; GCN-NEXT:    buffer_store_dword v0, v[2:3], s[4:7], 0 addr64
 ; GCN-NEXT:    s_endpgm
 ;
 ; GFX9-LABEL: sub_sext_setcc_commute:
 ; GFX9:       ; %bb.0: ; %bb
 ; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
 ; GFX9-NEXT:    v_lshlrev_b32_e32 v2, 2, v0
 ; GFX9-NEXT:    v_cmp_gt_u32_e32 vcc, v0, v1
 ; GFX9-NEXT:    v_cndmask_b32_e64 v0, 0, -1, vcc
 ; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
 ; GFX9-NEXT:    global_load_dword v3, v2, s[0:1]
+; GFX9-NEXT:    s_sub_i32 s2, s2, s3
 ; GFX9-NEXT:    s_waitcnt vmcnt(0)
 ; GFX9-NEXT:    v_sub_u32_e32 v0, v0, v3
 ; GFX9-NEXT:    v_add_u32_e32 v0, s2, v0
-; GFX9-NEXT:    v_subrev_u32_e32 v0, s3, v0
 ; GFX9-NEXT:    global_store_dword v2, v0, s[0:1]
 ; GFX9-NEXT:    s_endpgm
 bb:
   %x = tail call i32 @llvm.amdgcn.workitem.id.x()
   %y = tail call i32 @llvm.amdgcn.workitem.id.y()
   %gep = getelementptr inbounds i32, ptr addrspace(1) %arg, i32 %x
   %v = load i32, ptr addrspace(1) %gep, align 4
   %cmp = icmp ugt i32 %x, %y

llvm/test/CodeGen/AMDGPU/reassoc-sub-add.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
+; RUN: llc -mtriple=amdgcn -mcpu=tonga -verify-machineinstrs < %s | FileCheck -check-prefixes=GFX8 %s
+; RUN: llc -mtriple=amdgcn -mcpu=gfx900 -verify-machineinstrs < %s | FileCheck -check-prefixes=GFX9 %s
+
+; s0 + (s1 - v0) --> (s0 + s1) - v0
+define amdgpu_kernel void @reassoc_sub_add_s0s1v0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_add_s0s1v0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_add_i32 s2, s3, s2
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_add_s0s1v0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_add_i32 s2, s3, s2
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub = sub i32 %x, %tid
+  %add = add i32 %y, %sub
+  store i32 %add, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; s0 + (v0 - s1) --> (s0 - s1) + v0
+define amdgpu_kernel void @reassoc_sub_add_s0v0s1_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_add_s0v0s1_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_add_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_add_s0v0s1_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_add_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub = sub i32 %tid, %x
+  %add = add i32 %y, %sub
+  store i32 %add, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; (v0 - s1) + s0 --> (s0 - s1) + v0
+define amdgpu_kernel void @reassoc_sub_add_v0s1s0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_add_v0s1s0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_add_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_add_v0s1s0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_add_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub = sub i32 %tid, %x
+  %add = add i32 %sub, %y
+  store i32 %add, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; s0 - (s1 - v0) --> (s0 - s1) + v0
+define amdgpu_kernel void @reassoc_sub_sub_s0s1v0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_sub_s0s1v0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_add_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_sub_s0s1v0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_add_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub1 = sub i32 %x, %tid
+  %sub2 = sub i32 %y, %sub1
+  store i32 %sub2, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; s0 - (v0 - s1) --> (s0 + s1) - v0
+define amdgpu_kernel void @reassoc_sub_sub_s0v0s1_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_sub_s0v0s1_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_add_i32 s2, s3, s2
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_sub_s0v0s1_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_add_i32 s2, s3, s2
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub1 = sub i32 %tid, %x
+  %sub2 = sub i32 %y, %sub1
+  store i32 %sub2, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; s0 - (s1 + v0) --> (s0 - s1) - v0
+define amdgpu_kernel void @reassoc_add_sub_s0s1v0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_add_sub_s0s1v0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_add_sub_s0s1v0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %add = add i32 %x, %tid
+  %sub = sub i32 %y, %add
+  store i32 %sub, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; s0 - (v0 + s1) --> (s0 - s1) - v0
+define amdgpu_kernel void @reassoc_add_sub_s0v0s1_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_add_sub_s0v0s1_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_add_sub_s0v0s1_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %add = add i32 %tid, %x
+  %sub = sub i32 %y, %add
+  store i32 %sub, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; (s1 + v0) - s0 --> (s1 - s0) + v0
+define amdgpu_kernel void @reassoc_add_sub_s1v0s0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_add_sub_s1v0s0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s3, s2
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_add_sub_s1v0s0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s3, s2
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %add = add i32 %tid, %x
+  %sub = sub i32 %y, %add
+  store i32 %sub, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; (s1 - v0) - s0 --> (s1 - s0) - v0
+define amdgpu_kernel void @reassoc_sub_sub_s1v0s0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_sub_s1v0s0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_sub_i32 s2, s2, s3
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_sub_s1v0s0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_sub_i32 s2, s2, s3
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub1 = sub i32 %x, %tid
+  %sub2 = sub i32 %sub1, %y
+  store i32 %sub2, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; (s1 - v0) + s0 --> (s0 + s1) - v0
+define amdgpu_kernel void @reassoc_sub_add_s1v0s0_i32(ptr addrspace(1) %arg, i32 %x, i32 %y) {
+; GFX8-LABEL: reassoc_sub_add_s1v0s0_i32:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX8-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX8-NEXT:    s_add_i32 s2, s2, s3
+; GFX8-NEXT:    v_sub_u32_e32 v2, vcc, s2, v0
+; GFX8-NEXT:    v_mov_b32_e32 v0, s0
+; GFX8-NEXT:    v_mov_b32_e32 v1, s1
+; GFX8-NEXT:    flat_store_dword v[0:1], v2
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: reassoc_sub_add_s1v0s0_i32:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    s_load_dwordx4 s[0:3], s[0:1], 0x24
+; GFX9-NEXT:    v_mov_b32_e32 v1, 0
+; GFX9-NEXT:    s_waitcnt lgkmcnt(0)
+; GFX9-NEXT:    s_add_i32 s2, s2, s3
+; GFX9-NEXT:    v_sub_u32_e32 v0, s2, v0
+; GFX9-NEXT:    global_store_dword v1, v0, s[0:1]
+; GFX9-NEXT:    s_endpgm
+bb:
+  %tid = tail call i32 @llvm.amdgcn.workitem.id.x()
+  %sub = sub i32 %x, %tid
+  %add = add i32 %sub, %y
+  store i32 %add, ptr addrspace(1) %arg, align 4
+  ret void
+}
+
+; If the uniform value is a constant, DAGCombiner also try to canonicalize sub patterns
+; cause the test dead loop. For now we limit the optimization to variables to workaround it.
+define amdgpu_cs void @f(i32 inreg %arg, i32 %arg1) {
+; GFX8-LABEL: f:
+; GFX8:       ; %bb.0: ; %bb
+; GFX8-NEXT:    v_add_u32_e32 v0, vcc, s0, v0
+; GFX8-NEXT:    s_mov_b32 s0, 0
+; GFX8-NEXT:    v_sub_u32_e32 v0, vcc, 0, v0
+; GFX8-NEXT:    s_mov_b32 s1, s0
+; GFX8-NEXT:    s_mov_b32 s2, s0
+; GFX8-NEXT:    s_mov_b32 s3, s0
+; GFX8-NEXT:    buffer_store_dword v0, off, s[0:3], 0
+; GFX8-NEXT:    s_endpgm
+;
+; GFX9-LABEL: f:
+; GFX9:       ; %bb.0: ; %bb
+; GFX9-NEXT:    v_add_u32_e32 v0, s0, v0
+; GFX9-NEXT:    s_mov_b32 s0, 0
+; GFX9-NEXT:    v_sub_u32_e32 v0, 0, v0
+; GFX9-NEXT:    s_mov_b32 s1, s0
+; GFX9-NEXT:    s_mov_b32 s2, s0
+; GFX9-NEXT:    s_mov_b32 s3, s0
+; GFX9-NEXT:    buffer_store_dword v0, off, s[0:3], 0
+; GFX9-NEXT:    s_endpgm
+bb:
+  %i = add i32 %arg1, %arg
+  %i2 = sub i32 0, %i
+  call void @llvm.amdgcn.raw.buffer.store.i32(i32 %i2, <4 x i32> zeroinitializer, i32 0, i32 0, i32 0)
+  ret void
+}
+
+declare i32 @llvm.amdgcn.workitem.id.x()
+declare void @llvm.amdgcn.raw.buffer.store.i32(i32, <4 x i32>, i32, i32, i32 immarg)