test/CodeGen/X86/masked_memop.ll

   1 ; RUN: llc -mtriple=x86_64-apple-darwin  -mcpu=knl < %s | FileCheck %s -check-prefix=AVX512
   2 ; RUN: llc -mtriple=x86_64-apple-darwin  -mcpu=core-avx2 < %s | FileCheck %s -check-prefix=AVX2
   3 ; RUN: opt -mtriple=x86_64-apple-darwin -codegenprepare -mcpu=corei7-avx -S < %s | FileCheck %s -check-prefix=AVX_SCALAR
   4 ; RUN: llc -mtriple=x86_64-apple-darwin  -mcpu=skx < %s | FileCheck %s -check-prefix=SKX
   5
   6 ; AVX512-LABEL: test1
   7 ; AVX512: vmovdqu32       (%rdi), %zmm0 {%k1} {z}
   8
   9 ; AVX2-LABEL: test1
  10 ; AVX2: vpmaskmovd      {{.*}}(%rdi)
  11 ; AVX2: vpmaskmovd      {{.*}}(%rdi)
  12 ; AVX2-NOT: blend
  13
  14 ; AVX_SCALAR-LABEL: test1
  15 ; AVX_SCALAR-NOT: masked
  16 ; AVX_SCALAR: extractelement
  17 ; AVX_SCALAR: insertelement
  18 ; AVX_SCALAR: extractelement
  19 ; AVX_SCALAR: insertelement
  20 define <16 x i32> @test1(<16 x i32> %trigger, <16 x i32>* %addr) {
  21   %mask = icmp eq <16 x i32> %trigger, zeroinitializer
  22   %res = call <16 x i32> @llvm.masked.load.v16i32(<16 x i32>* %addr, i32 4, <16 x i1>%mask, <16 x i32>undef)
  23   ret <16 x i32> %res
  24 }
  25
  26 ; AVX512-LABEL: test2
  27 ; AVX512: vmovdqu32       (%rdi), %zmm0 {%k1} {z}
  28
  29 ; AVX2-LABEL: test2
  30 ; AVX2: vpmaskmovd      {{.*}}(%rdi)
  31 ; AVX2: vpmaskmovd      {{.*}}(%rdi)
  32 ; AVX2-NOT: blend
  33 define <16 x i32> @test2(<16 x i32> %trigger, <16 x i32>* %addr) {
  34   %mask = icmp eq <16 x i32> %trigger, zeroinitializer
  35   %res = call <16 x i32> @llvm.masked.load.v16i32(<16 x i32>* %addr, i32 4, <16 x i1>%mask, <16 x i32>zeroinitializer)
  36   ret <16 x i32> %res
  37 }
  38
  39 ; AVX512-LABEL: test3
  40 ; AVX512: vmovdqu32       %zmm1, (%rdi) {%k1}
  41
  42 ; AVX_SCALAR-LABEL: test3
  43 ; AVX_SCALAR-NOT: masked
  44 ; AVX_SCALAR: extractelement
  45 ; AVX_SCALAR: store
  46 ; AVX_SCALAR: extractelement
  47 ; AVX_SCALAR: store
  48 ; AVX_SCALAR: extractelement
  49 ; AVX_SCALAR: store
  50 define void @test3(<16 x i32> %trigger, <16 x i32>* %addr, <16 x i32> %val) {
  51   %mask = icmp eq <16 x i32> %trigger, zeroinitializer
  52   call void @llvm.masked.store.v16i32(<16 x i32>%val, <16 x i32>* %addr, i32 4, <16 x i1>%mask)
  53   ret void
  54 }
  55
  56 ; AVX512-LABEL: test4
  57 ; AVX512: vmovups       (%rdi), %zmm{{.*{%k[1-7]}}}
  58
  59 ; AVX2-LABEL: test4
  60 ; AVX2: vmaskmovps      {{.*}}(%rdi)
  61 ; AVX2: vmaskmovps      {{.*}}(%rdi)
  62 ; AVX2: blend
  63 define <16 x float> @test4(<16 x i32> %trigger, <16 x float>* %addr, <16 x float> %dst) {
  64   %mask = icmp eq <16 x i32> %trigger, zeroinitializer
  65   %res = call <16 x float> @llvm.masked.load.v16f32(<16 x float>* %addr, i32 4, <16 x i1>%mask, <16 x float> %dst)
  66   ret <16 x float> %res
  67 }
  68
  69 ; AVX512-LABEL: test5
  70 ; AVX512: vmovupd (%rdi), %zmm1 {%k1}
  71
  72 ; AVX2-LABEL: test5
  73 ; AVX2: vmaskmovpd
  74 ; AVX2: vblendvpd
  75 ; AVX2: vmaskmovpd
  76 ; AVX2: vblendvpd
  77 define <8 x double> @test5(<8 x i32> %trigger, <8 x double>* %addr, <8 x double> %dst) {
  78   %mask = icmp eq <8 x i32> %trigger, zeroinitializer
  79   %res = call <8 x double> @llvm.masked.load.v8f64(<8 x double>* %addr, i32 4, <8 x i1>%mask, <8 x double>%dst)
  80   ret <8 x double> %res
  81 }
  82
  83 ; AVX2-LABEL: test6
  84 ; AVX2: vmaskmovpd
  85 ; AVX2: vblendvpd
  86
  87 ; SKX-LABEL: test6
  88 ; SKX: vmovupd {{.*}}{%k1}
  89 define <2 x double> @test6(<2 x i64> %trigger, <2 x double>* %addr, <2 x double> %dst) {
  90   %mask = icmp eq <2 x i64> %trigger, zeroinitializer
  91   %res = call <2 x double> @llvm.masked.load.v2f64(<2 x double>* %addr, i32 4, <2 x i1>%mask, <2 x double>%dst)
  92   ret <2 x double> %res
  93 }
  94
  95 ; AVX2-LABEL: test7
  96 ; AVX2: vmaskmovps      {{.*}}(%rdi)
  97 ; AVX2: blend
  98
  99 ; SKX-LABEL: test7
 100 ; SKX: vmovups (%rdi){{.*}}{%k1}
 101 define <4 x float> @test7(<4 x i32> %trigger, <4 x float>* %addr, <4 x float> %dst) {
 102   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 103   %res = call <4 x float> @llvm.masked.load.v4f32(<4 x float>* %addr, i32 4, <4 x i1>%mask, <4 x float>%dst)
 104   ret <4 x float> %res
 105 }
 106
 107 ; AVX2-LABEL: test8
 108 ; AVX2: vpmaskmovd      {{.*}}(%rdi)
 109 ; AVX2: blend
 110
 111 ; SKX-LABEL: test8
 112 ; SKX: vmovdqu32 (%rdi){{.*}}{%k1}
 113 define <4 x i32> @test8(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %dst) {
 114   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 115   %res = call <4 x i32> @llvm.masked.load.v4i32(<4 x i32>* %addr, i32 4, <4 x i1>%mask, <4 x i32>%dst)
 116   ret <4 x i32> %res
 117 }
 118
 119 ; AVX2-LABEL: test9
 120 ; AVX2: vpmaskmovd %xmm
 121
 122 ; SKX-LABEL: test9
 123 ; SKX: vmovdqu32 %xmm{{.*}}{%k1}
 124 define void @test9(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %val) {
 125   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 126   call void @llvm.masked.store.v4i32(<4 x i32>%val, <4 x i32>* %addr, i32 4, <4 x i1>%mask)
 127   ret void
 128 }
 129
 130 ; AVX2-LABEL: test10
 131 ; AVX2: vmaskmovpd    (%rdi), %ymm
 132 ; AVX2: blend
 133
 134 ; SKX-LABEL: test10
 135 ; SKX: vmovapd {{.*}}{%k1}
 136 define <4 x double> @test10(<4 x i32> %trigger, <4 x double>* %addr, <4 x double> %dst) {
 137   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 138   %res = call <4 x double> @llvm.masked.load.v4f64(<4 x double>* %addr, i32 32, <4 x i1>%mask, <4 x double>%dst)
 139   ret <4 x double> %res
 140 }
 141
 142 ; AVX2-LABEL: test11
 143 ; AVX2: vmaskmovps
 144 ; AVX2: vblendvps
 145
 146 ; SKX-LABEL: test11
 147 ; SKX: vmovaps {{.*}}{%k1}
 148 define <8 x float> @test11(<8 x i32> %trigger, <8 x float>* %addr, <8 x float> %dst) {
 149   %mask = icmp eq <8 x i32> %trigger, zeroinitializer
 150   %res = call <8 x float> @llvm.masked.load.v8f32(<8 x float>* %addr, i32 32, <8 x i1>%mask, <8 x float>%dst)
 151   ret <8 x float> %res
 152 }
 153
 154 ; AVX2-LABEL: test12
 155 ; AVX2: vpmaskmovd %ymm
 156
 157 ; SKX-LABEL: test12
 158 ; SKX: vmovdqu32 {{.*}}{%k1}
 159 define void @test12(<8 x i32> %trigger, <8 x i32>* %addr, <8 x i32> %val) {
 160   %mask = icmp eq <8 x i32> %trigger, zeroinitializer
 161   call void @llvm.masked.store.v8i32(<8 x i32>%val, <8 x i32>* %addr, i32 4, <8 x i1>%mask)
 162   ret void
 163 }
 164
 165 ; AVX512-LABEL: test13
 166 ; AVX512: vmovups       %zmm1, (%rdi) {%k1}
 167
 168 define void @test13(<16 x i32> %trigger, <16 x float>* %addr, <16 x float> %val) {
 169   %mask = icmp eq <16 x i32> %trigger, zeroinitializer
 170   call void @llvm.masked.store.v16f32(<16 x float>%val, <16 x float>* %addr, i32 4, <16 x i1>%mask)
 171   ret void
 172 }
 173
 174 ; AVX2-LABEL: test14
 175 ; AVX2: vpshufd
 176 ; AVX2: vmovq
 177 ; AVX2: vmaskmovps
 178
 179 ; SKX-LABEL: test14
 180 ; SKX: kshiftl
 181 ; SKX: kshiftr
 182 ; SKX: vmovups {{.*}}{%k1}
 183
 184 define void @test14(<2 x i32> %trigger, <2 x float>* %addr, <2 x float> %val) {
 185   %mask = icmp eq <2 x i32> %trigger, zeroinitializer
 186   call void @llvm.masked.store.v2f32(<2 x float>%val, <2 x float>* %addr, i32 4, <2 x i1>%mask)
 187   ret void
 188 }
 189
 190 ; AVX2-LABEL: test15
 191 ; AVX2: vpmaskmovd
 192
 193 ; SKX-LABEL: test15:
 194 ; SKX:       ## BB#0:
 195 ; SKX-NEXT:    vpxor %xmm2, %xmm2, %xmm2
 196 ; SKX-NEXT:    vpblendd {{.*#+}} xmm0 = xmm0[0],xmm2[1],xmm0[2],xmm2[3]
 197 ; SKX-NEXT:    vpcmpeqq %xmm2, %xmm0, %k1
 198 ; SKX-NEXT:    vpmovqd %xmm1, (%rdi) {%k1}
 199 ; SKX-NEXT:    retq
 200 define void @test15(<2 x i32> %trigger, <2 x i32>* %addr, <2 x i32> %val) {
 201   %mask = icmp eq <2 x i32> %trigger, zeroinitializer
 202   call void @llvm.masked.store.v2i32(<2 x i32>%val, <2 x i32>* %addr, i32 4, <2 x i1>%mask)
 203   ret void
 204 }
 205
 206 ; AVX2-LABEL: test16
 207 ; AVX2: vmaskmovps
 208 ; AVX2: vblendvps
 209
 210 ; SKX-LABEL: test16
 211 ; SKX: kshiftl
 212 ; SKX: kshiftr
 213 ; SKX: vmovups {{.*}}{%k1}
 214 define <2 x float> @test16(<2 x i32> %trigger, <2 x float>* %addr, <2 x float> %dst) {
 215   %mask = icmp eq <2 x i32> %trigger, zeroinitializer
 216   %res = call <2 x float> @llvm.masked.load.v2f32(<2 x float>* %addr, i32 4, <2 x i1>%mask, <2 x float>%dst)
 217   ret <2 x float> %res
 218 }
 219
 220 ; AVX2-LABEL: test17
 221 ; AVX2: vpmaskmovd
 222 ; AVX2: vblendvps
 223 ; AVX2: vpmovsxdq
 224
 225 ; SKX-LABEL: test17
 226 ; SKX: kshiftl
 227 ; SKX: kshiftr
 228 ; SKX: vmovdqu32 {{.*}}{%k1}
 229 define <2 x i32> @test17(<2 x i32> %trigger, <2 x i32>* %addr, <2 x i32> %dst) {
 230   %mask = icmp eq <2 x i32> %trigger, zeroinitializer
 231   %res = call <2 x i32> @llvm.masked.load.v2i32(<2 x i32>* %addr, i32 4, <2 x i1>%mask, <2 x i32>%dst)
 232   ret <2 x i32> %res
 233 }
 234
 235 ; AVX2-LABEL: test18
 236 ; AVX2: vmaskmovps
 237 ; AVX2-NOT: blend
 238 ; AVX2: ret
 239 define <2 x float> @test18(<2 x i32> %trigger, <2 x float>* %addr) {
 240   %mask = icmp eq <2 x i32> %trigger, zeroinitializer
 241   %res = call <2 x float> @llvm.masked.load.v2f32(<2 x float>* %addr, i32 4, <2 x i1>%mask, <2 x float>undef)
 242   ret <2 x float> %res
 243 }
 244
 245 ; AVX_SCALAR-LABEL: test19
 246 ; AVX_SCALAR: load <4 x float>, <4 x float>* %addr, align 4
 247
 248 define <4 x float> @test19(<4 x i32> %trigger, <4 x float>* %addr) {
 249   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 250   %res = call <4 x float> @llvm.masked.load.v4f32(<4 x float>* %addr, i32 4, <4 x i1><i1 true, i1 true, i1 true, i1 true>, <4 x float>undef)
 251   ret <4 x float> %res
 252 }
 253
 254 ; AVX_SCALAR-LABEL: test20
 255 ; AVX_SCALAR: load float, {{.*}}, align 4
 256 ; AVX_SCALAR: insertelement <4 x float> undef, float
 257 ; AVX_SCALAR: select <4 x i1> <i1 true, i1 false, i1 true, i1 true>
 258
 259 define <4 x float> @test20(<4 x i32> %trigger, <4 x float>* %addr, <4 x float> %src0) {
 260   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 261   %res = call <4 x float> @llvm.masked.load.v4f32(<4 x float>* %addr, i32 16, <4 x i1><i1 true, i1 false, i1 true, i1 true>, <4 x float> %src0)
 262   ret <4 x float> %res
 263 }
 264
 265 ; AVX_SCALAR-LABEL: test21
 266 ; AVX_SCALAR: store <4 x i32> %val
 267 define void @test21(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %val) {
 268   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 269   call void @llvm.masked.store.v4i32(<4 x i32>%val, <4 x i32>* %addr, i32 4, <4 x i1><i1 true, i1 true, i1 true, i1 true>)
 270   ret void
 271 }
 272
 273 ; AVX_SCALAR-LABEL: test22
 274 ; AVX_SCALAR: extractelement <4 x i32> %val, i32 0
 275 ; AVX_SCALAR:  store i32
 276 define void @test22(<4 x i32> %trigger, <4 x i32>* %addr, <4 x i32> %val) {
 277   %mask = icmp eq <4 x i32> %trigger, zeroinitializer
 278   call void @llvm.masked.store.v4i32(<4 x i32>%val, <4 x i32>* %addr, i32 4, <4 x i1><i1 true, i1 false, i1 false, i1 false>)
 279   ret void
 280 }
 281
 282 declare <16 x i32> @llvm.masked.load.v16i32(<16 x i32>*, i32, <16 x i1>, <16 x i32>)
 283 declare <4 x i32> @llvm.masked.load.v4i32(<4 x i32>*, i32, <4 x i1>, <4 x i32>)
 284 declare <2 x i32> @llvm.masked.load.v2i32(<2 x i32>*, i32, <2 x i1>, <2 x i32>)
 285 declare void @llvm.masked.store.v16i32(<16 x i32>, <16 x i32>*, i32, <16 x i1>)
 286 declare void @llvm.masked.store.v8i32(<8 x i32>, <8 x i32>*, i32, <8 x i1>)
 287 declare void @llvm.masked.store.v4i32(<4 x i32>, <4 x i32>*, i32, <4 x i1>)
 288 declare void @llvm.masked.store.v2f32(<2 x float>, <2 x float>*, i32, <2 x i1>)
 289 declare void @llvm.masked.store.v2i32(<2 x i32>, <2 x i32>*, i32, <2 x i1>)
 290 declare void @llvm.masked.store.v16f32(<16 x float>, <16 x float>*, i32, <16 x i1>)
 291 declare void @llvm.masked.store.v16f32p(<16 x float>*, <16 x float>**, i32, <16 x i1>)
 292 declare <16 x float> @llvm.masked.load.v16f32(<16 x float>*, i32, <16 x i1>, <16 x float>)
 293 declare <8 x float> @llvm.masked.load.v8f32(<8 x float>*, i32, <8 x i1>, <8 x float>)
 294 declare <4 x float> @llvm.masked.load.v4f32(<4 x float>*, i32, <4 x i1>, <4 x float>)
 295 declare <2 x float> @llvm.masked.load.v2f32(<2 x float>*, i32, <2 x i1>, <2 x float>)
 296 declare <8 x double> @llvm.masked.load.v8f64(<8 x double>*, i32, <8 x i1>, <8 x double>)
 297 declare <4 x double> @llvm.masked.load.v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)
 298 declare <2 x double> @llvm.masked.load.v2f64(<2 x double>*, i32, <2 x i1>, <2 x double>)
 299 declare void @llvm.masked.store.v8f64(<8 x double>, <8 x double>*, i32, <8 x i1>)
 300 declare void @llvm.masked.store.v2f64(<2 x double>, <2 x double>*, i32, <2 x i1>)
 301 declare void @llvm.masked.store.v2i64(<2 x i64>, <2 x i64>*, i32, <2 x i1>)
 302
 303 declare <16 x i32*> @llvm.masked.load.v16p0i32(<16 x i32*>*, i32, <16 x i1>, <16 x i32*>)
 304
 305 ; AVX512-LABEL: test23
 306 ; AVX512: vmovdqu64       64(%rdi), %zmm1 {%k2} {z}
 307 ; AVX512: vmovdqu64       (%rdi), %zmm0 {%k1} {z}
 308
 309 define <16 x i32*> @test23(<16 x i32*> %trigger, <16 x i32*>* %addr) {
 310   %mask = icmp eq <16 x i32*> %trigger, zeroinitializer
 311   %res = call <16 x i32*> @llvm.masked.load.v16p0i32(<16 x i32*>* %addr, i32 4, <16 x i1>%mask, <16 x i32*>zeroinitializer)
 312   ret <16 x i32*> %res
 313 }
 314
 315 %mystruct = type { i16, i16, [1 x i8*] }
 316
 317 declare <16 x %mystruct*> @llvm.masked.load.v16p0mystruct(<16 x %mystruct*>*, i32, <16 x i1>, <16 x %mystruct*>)
 318
 319 ; AVX512-LABEL: test24
 320 ; AVX512: vmovdqu64       (%rdi), %zmm0 {%k1} {z}
 321 ; AVX512: kshiftrw        $8, %k1, %k1
 322 ; AVX512: vmovdqu64       64(%rdi), %zmm1 {%k1} {z}
 323
 324 define <16 x %mystruct*> @test24(<16 x i1> %mask, <16 x %mystruct*>* %addr) {
 325   %res = call <16 x %mystruct*> @llvm.masked.load.v16p0mystruct(<16 x %mystruct*>* %addr, i32 4, <16 x i1>%mask, <16 x %mystruct*>zeroinitializer)
 326   ret <16 x %mystruct*> %res
 327 }