llvm/test/CodeGen/AMDGPU/use-sgpr-multiple-times.ll

   1 ; RUN: llc -march=amdgcn -verify-machineinstrs < %s | FileCheck -check-prefix=SI -check-prefix=GCN %s
   2 ; RUN: llc -march=amdgcn -mcpu=tonga -mattr=-flat-for-global -verify-machineinstrs < %s | FileCheck -check-prefix=VI -check-prefix=GCN %s
   3
   4 declare float @llvm.fma.f32(float, float, float) #1
   5 declare double @llvm.fma.f64(double, double, double) #1
   6 declare float @llvm.fmuladd.f32(float, float, float) #1
   7 declare float @llvm.amdgcn.div.fixup.f32(float, float, float) #1
   8
   9
  10 ; GCN-LABEL: {{^}}test_sgpr_use_twice_binop:
  11 ; GCN: s_load_dword [[SGPR:s[0-9]+]],
  12 ; GCN: v_add_f32_e64 [[RESULT:v[0-9]+]], [[SGPR]], [[SGPR]]
  13 ; GCN: buffer_store_dword [[RESULT]]
  14 define amdgpu_kernel void @test_sgpr_use_twice_binop(float addrspace(1)* %out, float %a) #0 {
  15   %dbl = fadd float %a, %a
  16   store float %dbl, float addrspace(1)* %out, align 4
  17   ret void
  18 }
  19
  20 ; GCN-LABEL: {{^}}test_sgpr_use_three_ternary_op:
  21 ; GCN: s_load_dword [[SGPR:s[0-9]+]],
  22 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[SGPR]], [[SGPR]], [[SGPR]]
  23 ; GCN: buffer_store_dword [[RESULT]]
  24 define amdgpu_kernel void @test_sgpr_use_three_ternary_op(float addrspace(1)* %out, float %a) #0 {
  25   %fma = call float @llvm.fma.f32(float %a, float %a, float %a) #1
  26   store float %fma, float addrspace(1)* %out, align 4
  27   ret void
  28 }
  29
  30 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_a_a_b:
  31 ; SI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0xb
  32 ; VI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0x2c
  33 ; GCN: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
  34 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], s[[SGPR0]], s[[SGPR0]], [[VGPR1]]
  35 ; GCN: buffer_store_dword [[RESULT]]
  36 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_a_a_b(float addrspace(1)* %out, float %a, float %b) #0 {
  37   %fma = call float @llvm.fma.f32(float %a, float %a, float %b) #1
  38   store float %fma, float addrspace(1)* %out, align 4
  39   ret void
  40 }
  41
  42 ; GCN-LABEL: {{^}}test_use_s_v_s:
  43 ; GCN-DAG: s_load_dwordx2 s{{\[}}[[SA:[0-9]+]]:[[SB:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, {{0xb|0x2c}}
  44 ; SI: buffer_load_dword [[VA0:v[0-9]+]]
  45 ; SI-NEXT: s_waitcnt vmcnt(0)
  46 ; SI-NEXT: buffer_load_dword [[VA1:v[0-9]+]]
  47 ; SI-NEXT: s_waitcnt vmcnt(0)
  48
  49 ; GCN-NOT: v_mov_b32
  50
  51 ; VI: buffer_load_dword [[VA0:v[0-9]+]]
  52 ; VI-NEXT: s_waitcnt vmcnt(0)
  53 ; VI-NEXT: buffer_load_dword [[VA1:v[0-9]+]]
  54 ; VI-NEXT: s_waitcnt vmcnt(0)
  55
  56 ; GCN-NOT: v_mov_b32
  57 ; GCN: v_mov_b32_e32 [[VB:v[0-9]+]], s[[SB]]
  58 ; GCN-NOT: v_mov_b32
  59
  60 ; GCN-DAG: v_fma_f32 [[RESULT0:v[0-9]+]], s[[SA]], [[VA0]], [[VB]]
  61 ; GCN-DAG: v_fma_f32 [[RESULT1:v[0-9]+]], s[[SA]], [[VA1]], [[VB]]
  62 ; GCN: buffer_store_dword [[RESULT0]]
  63 ; GCN: buffer_store_dword [[RESULT1]]
  64 define amdgpu_kernel void @test_use_s_v_s(float addrspace(1)* %out, float %a, float %b, float addrspace(1)* %in) #0 {
  65   %va0 = load volatile float, float addrspace(1)* %in
  66   %va1 = load volatile float, float addrspace(1)* %in
  67   %fma0 = call float @llvm.fma.f32(float %a, float %va0, float %b) #1
  68   %fma1 = call float @llvm.fma.f32(float %a, float %va1, float %b) #1
  69   store volatile float %fma0, float addrspace(1)* %out
  70   store volatile float %fma1, float addrspace(1)* %out
  71   ret void
  72 }
  73
  74 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_a_b_a:
  75 ; SI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0xb
  76 ; VI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0x2c
  77 ; GCN: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
  78 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], s[[SGPR0]], [[VGPR1]], s[[SGPR0]]
  79 ; GCN: buffer_store_dword [[RESULT]]
  80 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_a_b_a(float addrspace(1)* %out, float %a, float %b) #0 {
  81   %fma = call float @llvm.fma.f32(float %a, float %b, float %a) #1
  82   store float %fma, float addrspace(1)* %out, align 4
  83   ret void
  84 }
  85
  86 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_b_a_a:
  87 ; SI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0xb
  88 ; VI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0x2c
  89 ; GCN: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
  90 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[VGPR1]], s[[SGPR0]], s[[SGPR0]]
  91 ; GCN: buffer_store_dword [[RESULT]]
  92 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_b_a_a(float addrspace(1)* %out, float %a, float %b) #0 {
  93   %fma = call float @llvm.fma.f32(float %b, float %a, float %a) #1
  94   store float %fma, float addrspace(1)* %out, align 4
  95   ret void
  96 }
  97
  98 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_a_a_imm:
  99 ; GCN: s_load_dword [[SGPR:s[0-9]+]]
 100 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[SGPR]], [[SGPR]], 2.0
 101 ; GCN: buffer_store_dword [[RESULT]]
 102 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_a_a_imm(float addrspace(1)* %out, float %a) #0 {
 103   %fma = call float @llvm.fma.f32(float %a, float %a, float 2.0) #1
 104   store float %fma, float addrspace(1)* %out, align 4
 105   ret void
 106 }
 107
 108 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_a_imm_a:
 109 ; GCN: s_load_dword [[SGPR:s[0-9]+]]
 110 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[SGPR]], 2.0, [[SGPR]]
 111 ; GCN: buffer_store_dword [[RESULT]]
 112 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_a_imm_a(float addrspace(1)* %out, float %a) #0 {
 113   %fma = call float @llvm.fma.f32(float %a, float 2.0, float %a) #1
 114   store float %fma, float addrspace(1)* %out, align 4
 115   ret void
 116 }
 117
 118 ; Don't use fma since fma c, x, y is canonicalized to fma x, c, y
 119 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_imm_a_a:
 120 ; GCN: s_load_dword [[SGPR:s[0-9]+]]
 121 ; GCN: v_div_fixup_f32 [[RESULT:v[0-9]+]], 2.0, [[SGPR]], [[SGPR]]
 122 ; GCN: buffer_store_dword [[RESULT]]
 123 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_imm_a_a(float addrspace(1)* %out, float %a) #0 {
 124   %val = call float @llvm.amdgcn.div.fixup.f32(float 2.0, float %a, float %a) #1
 125   store float %val, float addrspace(1)* %out, align 4
 126   ret void
 127 }
 128
 129 ; GCN-LABEL: {{^}}test_sgpr_use_twice_ternary_op_a_a_kimm:
 130 ; GCN-DAG: s_load_dword [[SGPR:s[0-9]+]]
 131 ; GCN-DAG: v_mov_b32_e32 [[VK:v[0-9]+]], 0x44800000
 132 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[SGPR]], [[SGPR]], [[VK]]
 133 ; GCN: buffer_store_dword [[RESULT]]
 134 define amdgpu_kernel void @test_sgpr_use_twice_ternary_op_a_a_kimm(float addrspace(1)* %out, float %a) #0 {
 135   %fma = call float @llvm.fma.f32(float %a, float %a, float 1024.0) #1
 136   store float %fma, float addrspace(1)* %out, align 4
 137   ret void
 138 }
 139
 140 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_k_k_s:
 141 ; GCN-DAG: s_load_dword [[SGPR:s[0-9]+]]
 142 ; GCN-DAG: v_mov_b32_e32 [[VGPR:v[0-9]+]], [[SGPR]]
 143 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 144 ; GCN: v_fma_f32 [[RESULT0:v[0-9]+]], [[SK]], [[SK]], [[VGPR]]
 145 ; GCN: buffer_store_dword [[RESULT0]]
 146 define amdgpu_kernel void @test_literal_use_twice_ternary_op_k_k_s(float addrspace(1)* %out, float %a) #0 {
 147   %fma = call float @llvm.fma.f32(float 1024.0, float 1024.0, float %a) #1
 148   store float %fma, float addrspace(1)* %out
 149   ret void
 150 }
 151
 152 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_k_k_s_x2:
 153 ; GCN-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]{{\:}}[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, {{0xb|0x2c}}
 154 ; GCN-DAG: v_mov_b32_e32 [[VGPR0:v[0-9]+]], s[[SGPR0]]
 155 ; GCN-DAG: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
 156 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 157 ; GCN-DAG: v_fma_f32 [[RESULT0:v[0-9]+]], [[SK]], [[SK]], [[VGPR0]]
 158 ; GCN-DAG: v_fma_f32 [[RESULT1:v[0-9]+]], [[SK]], [[SK]], [[VGPR1]]
 159 ; GCN: buffer_store_dword [[RESULT0]]
 160 ; GCN: buffer_store_dword [[RESULT1]]
 161 ; GCN: s_endpgm
 162 define amdgpu_kernel void @test_literal_use_twice_ternary_op_k_k_s_x2(float addrspace(1)* %out, float %a, float %b) #0 {
 163   %fma0 = call float @llvm.fma.f32(float 1024.0, float 1024.0, float %a) #1
 164   %fma1 = call float @llvm.fma.f32(float 1024.0, float 1024.0, float %b) #1
 165   store volatile float %fma0, float addrspace(1)* %out
 166   store volatile float %fma1, float addrspace(1)* %out
 167   ret void
 168 }
 169
 170 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_k_s_k:
 171 ; GCN-DAG: s_load_dword [[SGPR:s[0-9]+]]
 172 ; GCN-DAG: v_mov_b32_e32 [[VGPR:v[0-9]+]], [[SGPR]]
 173 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 174 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[VGPR]], [[SK]], [[SK]]
 175 ; GCN: buffer_store_dword [[RESULT]]
 176 define amdgpu_kernel void @test_literal_use_twice_ternary_op_k_s_k(float addrspace(1)* %out, float %a) #0 {
 177   %fma = call float @llvm.fma.f32(float 1024.0, float %a, float 1024.0) #1
 178   store float %fma, float addrspace(1)* %out
 179   ret void
 180 }
 181
 182 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_k_s_k_x2:
 183 ; GCN-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]{{\:}}[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, {{0xb|0x2c}}
 184 ; GCN-DAG: v_mov_b32_e32 [[VGPR0:v[0-9]+]], s[[SGPR0]]
 185 ; GCN-DAG: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
 186 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 187 ; GCN-DAG: v_fma_f32 [[RESULT0:v[0-9]+]], [[VGPR0]], [[SK]], [[SK]]
 188 ; GCN-DAG: v_fma_f32 [[RESULT1:v[0-9]+]], [[VGPR1]], [[SK]], [[SK]]
 189 ; GCN: buffer_store_dword [[RESULT0]]
 190 ; GCN: buffer_store_dword [[RESULT1]]
 191 ; GCN: s_endpgm
 192 define amdgpu_kernel void @test_literal_use_twice_ternary_op_k_s_k_x2(float addrspace(1)* %out, float %a, float %b) #0 {
 193   %fma0 = call float @llvm.fma.f32(float 1024.0, float %a, float 1024.0) #1
 194   %fma1 = call float @llvm.fma.f32(float 1024.0, float %b, float 1024.0) #1
 195   store volatile float %fma0, float addrspace(1)* %out
 196   store volatile float %fma1, float addrspace(1)* %out
 197   ret void
 198 }
 199
 200 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_s_k_k:
 201 ; GCN-DAG: s_load_dword [[SGPR:s[0-9]+]]
 202 ; GCN-DAG: v_mov_b32_e32 [[VGPR:v[0-9]+]], [[SGPR]]
 203 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 204 ; GCN: v_fma_f32 [[RESULT:v[0-9]+]], [[VGPR]], [[SK]], [[SK]]
 205 ; GCN: buffer_store_dword [[RESULT]]
 206 define amdgpu_kernel void @test_literal_use_twice_ternary_op_s_k_k(float addrspace(1)* %out, float %a) #0 {
 207   %fma = call float @llvm.fma.f32(float %a, float 1024.0, float 1024.0) #1
 208   store float %fma, float addrspace(1)* %out
 209   ret void
 210 }
 211
 212 ; GCN-LABEL: {{^}}test_literal_use_twice_ternary_op_s_k_k_x2:
 213 ; GCN-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]{{\:}}[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, {{0xb|0x2c}}
 214 ; GCN-DAG: v_mov_b32_e32 [[VGPR0:v[0-9]+]], s[[SGPR0]]
 215 ; GCN-DAG: v_mov_b32_e32 [[VGPR1:v[0-9]+]], s[[SGPR1]]
 216 ; GCN-DAG: s_mov_b32 [[SK:s[0-9]+]], 0x44800000
 217 ; GCN-DAG: v_fma_f32 [[RESULT0:v[0-9]+]], [[VGPR0]], [[SK]], [[SK]]
 218 ; GCN-DAG: v_fma_f32 [[RESULT1:v[0-9]+]], [[VGPR1]], [[SK]], [[SK]]
 219 ; GCN: buffer_store_dword [[RESULT0]]
 220 ; GCN: buffer_store_dword [[RESULT1]]
 221 ; GCN: s_endpgm
 222 define amdgpu_kernel void @test_literal_use_twice_ternary_op_s_k_k_x2(float addrspace(1)* %out, float %a, float %b) #0 {
 223   %fma0 = call float @llvm.fma.f32(float %a, float 1024.0, float 1024.0) #1
 224   %fma1 = call float @llvm.fma.f32(float %b, float 1024.0, float 1024.0) #1
 225   store volatile float %fma0, float addrspace(1)* %out
 226   store volatile float %fma1, float addrspace(1)* %out
 227   ret void
 228 }
 229
 230 ; GCN-LABEL: {{^}}test_s0_s1_k_f32:
 231 ; SI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0xb
 232 ; VI-DAG: s_load_dwordx2 s{{\[}}[[SGPR0:[0-9]+]]:[[SGPR1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, 0x2c
 233 ; GCN-DAG: v_mov_b32_e32 [[VK0:v[0-9]+]], 0x44800000
 234 ; GCN-DAG: v_mov_b32_e32 [[VS1:v[0-9]+]], s[[SGPR1]]
 235
 236 ; GCN-DAG: v_fma_f32 [[RESULT0:v[0-9]+]], s[[SGPR0]], [[VS1]], [[VK0]]
 237 ; GCN-DAG: v_mov_b32_e32 [[VK1:v[0-9]+]], 0x45800000
 238 ; GCN-DAG: v_fma_f32 [[RESULT1:v[0-9]+]], s[[SGPR0]], [[VS1]], [[VK1]]
 239
 240 ; GCN: buffer_store_dword [[RESULT0]]
 241 ; GCN: buffer_store_dword [[RESULT1]]
 242 define amdgpu_kernel void @test_s0_s1_k_f32(float addrspace(1)* %out, float %a, float %b) #0 {
 243   %fma0 = call float @llvm.fma.f32(float %a, float %b, float 1024.0) #1
 244   %fma1 = call float @llvm.fma.f32(float %a, float %b, float 4096.0) #1
 245   store volatile float %fma0, float addrspace(1)* %out
 246   store volatile float %fma1, float addrspace(1)* %out
 247   ret void
 248 }
 249
 250 ; FIXME: Immediate in SGPRs just copied to VGPRs
 251 ; GCN-LABEL: {{^}}test_s0_s1_k_f64:
 252 ; GCN-DAG: s_load_dwordx2 [[SGPR0:s\[[0-9]+:[0-9]+\]]], s{{\[[0-9]+:[0-9]+\]}}, {{0x13|0x4c}}
 253 ; GCN-DAG: s_load_dwordx2 s{{\[}}[[SGPR1_SUB0:[0-9]+]]:[[SGPR1_SUB1:[0-9]+]]{{\]}}, s{{\[[0-9]+:[0-9]+\]}}, {{0x1d|0x74}}
 254 ; GCN-DAG: v_mov_b32_e32 v[[VK0_SUB1:[0-9]+]], 0x40900000
 255 ; GCN-DAG: v_mov_b32_e32 v[[VZERO:[0-9]+]], 0{{$}}
 256
 257 ; GCN-DAG: v_mov_b32_e32 v[[VS1_SUB0:[0-9]+]], s[[SGPR1_SUB0]]
 258 ; GCN-DAG: v_mov_b32_e32 v[[VS1_SUB1:[0-9]+]], s[[SGPR1_SUB1]]
 259 ; GCN: v_fma_f64 [[RESULT0:v\[[0-9]+:[0-9]+\]]], [[SGPR0]], v{{\[}}[[VS1_SUB0]]:[[VS1_SUB1]]{{\]}}, v{{\[}}[[VZERO]]:[[VK0_SUB1]]{{\]}}
 260
 261 ; Same zero component is re-used for half of each immediate.
 262 ; GCN: v_mov_b32_e32 v[[VK1_SUB1:[0-9]+]], 0x40b00000
 263 ; GCN: v_fma_f64 [[RESULT1:v\[[0-9]+:[0-9]+\]]], [[SGPR0]], v{{\[}}[[VS1_SUB0]]:[[VS1_SUB1]]{{\]}}, v{{\[}}[[VZERO]]:[[VK1_SUB1]]{{\]}}
 264
 265 ; GCN: buffer_store_dwordx2 [[RESULT0]]
 266 ; GCN: buffer_store_dwordx2 [[RESULT1]]
 267 define amdgpu_kernel void @test_s0_s1_k_f64(double addrspace(1)* %out, [8 x i32], double %a, [8 x i32], double %b) #0 {
 268   %fma0 = call double @llvm.fma.f64(double %a, double %b, double 1024.0) #1
 269   %fma1 = call double @llvm.fma.f64(double %a, double %b, double 4096.0) #1
 270   store volatile double %fma0, double addrspace(1)* %out
 271   store volatile double %fma1, double addrspace(1)* %out
 272   ret void
 273 }
 274
 275 attributes #0 = { nounwind }
 276 attributes #1 = { nounwind readnone }