llvm/test/CodeGen/AMDGPU/select-undef.ll

   1 ; RUN: llc -amdgpu-scalar-ir-passes=0 -mtriple=amdgcn-amd-amdhsa -mcpu=gfx900 < %s | FileCheck -check-prefix=GCN %s
   2
   3 ; GCN-LABEL: {{^}}select_undef_lhs:
   4 ; GCN: s_waitcnt
   5 ; GCN-NOT: v_cmp
   6 ; GCN-NOT: v_cndmask
   7 ; GCN-NEXT: s_setpc_b64
   8 define float @select_undef_lhs(float %val, i1 %cond) {
   9   %sel = select i1 %cond, float undef, float %val
  10   ret float %sel
  11 }
  12
  13 ; GCN-LABEL: {{^}}select_undef_rhs:
  14 ; GCN: s_waitcnt
  15 ; GCN-NOT: v_cmp
  16 ; GCN-NOT: v_cndmask
  17 ; GCN-NEXT: s_setpc_b64
  18 define float @select_undef_rhs(float %val, i1 %cond) {
  19   %sel = select i1 %cond, float %val, float undef
  20   ret float %sel
  21 }
  22
  23 ; GCN-LABEL: {{^}}select_undef_n1:
  24 ; GCN: v_mov_b32_e32 [[RES:v[0-9]+]], 1.0
  25 ; GCN: store_dword {{[^,]+}}, [[RES]]
  26 define void @select_undef_n1(ptr addrspace(1) %a, i32 %c) {
  27   %cc = icmp eq i32 %c, 0
  28   %sel = select i1 %cc, float 1.000000e+00, float undef
  29   store float %sel, ptr addrspace(1) %a
  30   ret void
  31 }
  32
  33 ; GCN-LABEL: {{^}}select_undef_n2:
  34 ; GCN: v_mov_b32_e32 [[RES:v[0-9]+]], 1.0
  35 ; GCN: store_dword {{[^,]+}}, [[RES]]
  36 define void @select_undef_n2(ptr addrspace(1) %a, i32 %c) {
  37   %cc = icmp eq i32 %c, 0
  38   %sel = select i1 %cc, float undef, float 1.000000e+00
  39   store float %sel, ptr addrspace(1) %a
  40   ret void
  41 }
  42
  43 declare float @llvm.amdgcn.rcp.f32(float)
  44
  45
  46 ; Make sure the vector undef isn't lowered into 0s.
  47 ; GCN-LABEL: {{^}}undef_v6f32:
  48 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
  49 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
  50 ; GCN: s_cbranch_vccnz
  51 define amdgpu_kernel void @undef_v6f32(ptr addrspace(3) %ptr, i1 %cond) {
  52 entry:
  53   br label %loop
  54
  55 loop:
  56   %phi = phi <6 x float> [ undef, %entry ], [ %add, %loop ]
  57   %load = load volatile <6 x float>, ptr addrspace(3) undef
  58   %add = fadd <6 x float> %load, %phi
  59   br i1 %cond, label %loop, label %ret
  60
  61 ret:
  62   store volatile <6 x float> %add, ptr addrspace(3) undef
  63   ret void
  64 }
  65
  66 ; GCN-LABEL: {{^}}undef_v6i32:
  67 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
  68 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
  69 ; GCN: s_cbranch_vccnz
  70 define amdgpu_kernel void @undef_v6i32(ptr addrspace(3) %ptr, i1 %cond) {
  71 entry:
  72   br label %loop
  73
  74 loop:
  75   %phi = phi <6 x i32> [ undef, %entry ], [ %add, %loop ]
  76   %load = load volatile <6 x i32>, ptr addrspace(3) undef
  77   %add = add <6 x i32> %load, %phi
  78   br i1 %cond, label %loop, label %ret
  79
  80 ret:
  81   store volatile <6 x i32> %add, ptr addrspace(3) undef
  82   ret void
  83 }
  84
  85 ; Make sure the vector undef isn't lowered into 0s.
  86 ; GCN-LABEL: {{^}}undef_v5f32:
  87 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
  88 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
  89 ; GCN: s_cbranch_vccnz
  90 define amdgpu_kernel void @undef_v5f32(ptr addrspace(3) %ptr, i1 %cond) {
  91 entry:
  92   br label %loop
  93
  94 loop:
  95   %phi = phi <5 x float> [ undef, %entry ], [ %add, %loop ]
  96   %load = load volatile <5 x float>, ptr addrspace(3) undef
  97   %add = fadd <5 x float> %load, %phi
  98   br i1 %cond, label %loop, label %ret
  99
 100 ret:
 101   store volatile <5 x float> %add, ptr addrspace(3) undef
 102   ret void
 103 }
 104
 105 ; GCN-LABEL: {{^}}undef_v5i32:
 106 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 107 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 108 ; GCN: s_cbranch_vccnz
 109 define amdgpu_kernel void @undef_v5i32(ptr addrspace(3) %ptr, i1 %cond) {
 110 entry:
 111   br label %loop
 112
 113 loop:
 114   %phi = phi <5 x i32> [ undef, %entry ], [ %add, %loop ]
 115   %load = load volatile <5 x i32>, ptr addrspace(3) undef
 116   %add = add <5 x i32> %load, %phi
 117   br i1 %cond, label %loop, label %ret
 118
 119 ret:
 120   store volatile <5 x i32> %add, ptr addrspace(3) undef
 121   ret void
 122 }
 123
 124 ; Make sure the vector undef isn't lowered into 0s.
 125 ; GCN-LABEL: {{^}}undef_v3f64:
 126 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 127 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 128 ; GCN: s_cbranch_vccnz
 129 define amdgpu_kernel void @undef_v3f64(ptr addrspace(3) %ptr, i1 %cond) {
 130 entry:
 131   br label %loop
 132
 133 loop:
 134   %phi = phi <3 x double> [ undef, %entry ], [ %add, %loop ]
 135   %load = load volatile <3 x double>, ptr addrspace(3) %ptr
 136   %add = fadd <3 x double> %load, %phi
 137   br i1 %cond, label %loop, label %ret
 138
 139 ret:
 140   store volatile <3 x double> %add, ptr addrspace(3) %ptr
 141   ret void
 142 }
 143
 144 ; GCN-LABEL: {{^}}undef_v3i64:
 145 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 146 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 147 ; GCN: s_cbranch_vccnz
 148 define amdgpu_kernel void @undef_v3i64(ptr addrspace(3) %ptr, i1 %cond) {
 149 entry:
 150   br label %loop
 151
 152 loop:
 153   %phi = phi <3 x i64> [ undef, %entry ], [ %add, %loop ]
 154   %load = load volatile <3 x i64>, ptr addrspace(3) %ptr
 155   %add = add <3 x i64> %load, %phi
 156   br i1 %cond, label %loop, label %ret
 157
 158 ret:
 159   store volatile <3 x i64> %add, ptr addrspace(3) %ptr
 160   ret void
 161 }
 162
 163 ; Make sure the vector undef isn't lowered into 0s.
 164 ; GCN-LABEL: {{^}}undef_v4f16:
 165 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 166 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 167 ; GCN: s_cbranch_vccnz
 168 define amdgpu_kernel void @undef_v4f16(ptr addrspace(3) %ptr, i1 %cond) {
 169 entry:
 170   br label %loop
 171
 172 loop:
 173   %phi = phi <4 x half> [ undef, %entry ], [ %add, %loop ]
 174   %load = load volatile <4 x half>, ptr addrspace(3) %ptr
 175   %add = fadd <4 x half> %load, %phi
 176   br i1 %cond, label %loop, label %ret
 177
 178 ret:
 179   store volatile <4 x half> %add, ptr addrspace(3) %ptr
 180   ret void
 181 }
 182
 183 ; GCN-LABEL: {{^}}undef_v4i16:
 184 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 185 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 186 ; GCN: s_cbranch_vccnz
 187 define amdgpu_kernel void @undef_v4i16(ptr addrspace(3) %ptr, i1 %cond) {
 188 entry:
 189   br label %loop
 190
 191 loop:
 192   %phi = phi <4 x i16> [ undef, %entry ], [ %add, %loop ]
 193   %load = load volatile <4 x i16>, ptr addrspace(3) %ptr
 194   %add = add <4 x i16> %load, %phi
 195   br i1 %cond, label %loop, label %ret
 196
 197 ret:
 198   store volatile <4 x i16> %add, ptr addrspace(3) %ptr
 199   ret void
 200 }
 201
 202 ; Make sure the vector undef isn't lowered into 0s.
 203 ; GCN-LABEL: {{^}}undef_v2f16:
 204 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 205 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 206 ; GCN: s_cbranch_vccnz
 207 define amdgpu_kernel void @undef_v2f16(ptr addrspace(3) %ptr, i1 %cond) {
 208 entry:
 209   br label %loop
 210
 211 loop:
 212   %phi = phi <2 x half> [ undef, %entry ], [ %add, %loop ]
 213   %load = load volatile <2 x half>, ptr addrspace(3) %ptr
 214   %add = fadd <2 x half> %load, %phi
 215   br i1 %cond, label %loop, label %ret
 216
 217 ret:
 218   store volatile <2 x half> %add, ptr addrspace(3) %ptr
 219   ret void
 220 }
 221
 222 ; GCN-LABEL: {{^}}undef_v2i16:
 223 ; GCN-NOT: v_mov_b32_e32 v{{[0-9]+}}, 0
 224 ; GCN-NOT: s_mov_b32 s{{[0-9]+}}, 0
 225 ; GCN: s_cbranch_vccnz
 226 define amdgpu_kernel void @undef_v2i16(ptr addrspace(3) %ptr, i1 %cond) {
 227 entry:
 228   br label %loop
 229
 230 loop:
 231   %phi = phi <2 x i16> [ undef, %entry ], [ %add, %loop ]
 232   %load = load volatile <2 x i16>, ptr addrspace(3) %ptr
 233   %add = add <2 x i16> %load, %phi
 234   br i1 %cond, label %loop, label %ret
 235
 236 ret:
 237   store volatile <2 x i16> %add, ptr addrspace(3) %ptr
 238   ret void
 239 }
 240
 241 ; We were expanding undef vectors into zero vectors. Optimizations
 242 ; would then see we used no elements of the vector, and reform the
 243 ; undef vector resulting in a combiner loop.
 244 ; GCN-LABEL: {{^}}inf_loop_undef_vector:
 245 ; GCN: s_waitcnt
 246 ; GCN-NEXT: v_mad_u64_u32
 247 ; GCN-NEXT: v_mul_lo_u32
 248 ; GCN-NEXT: v_mul_lo_u32
 249 ; GCN-NEXT: v_add3_u32
 250 ; GCN-NEXT: global_store_dwordx2
 251 define void @inf_loop_undef_vector(<6 x float> %arg, float %arg1, i64 %arg2) {
 252   %i = insertelement <6 x float> %arg, float %arg1, i64 2
 253   %i3 = bitcast <6 x float> %i to <3 x i64>
 254   %i4 = extractelement <3 x i64> %i3, i64 0
 255   %i5 = extractelement <3 x i64> %i3, i64 1
 256   %i6 = mul i64 %i5, %arg2
 257   %i7 = add i64 %i6, %i4
 258   store volatile i64 %i7, ptr addrspace(1) undef, align 4
 259   ret void
 260 }