test/CodeGen/X86/unaligned-32-byte-memops.ll

   1 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx,+slow-unaligned-mem-32 | FileCheck %s --check-prefix=AVXSLOW
   2 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx,-slow-unaligned-mem-32 | FileCheck %s --check-prefix=AVXFAST
   3 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx2 | FileCheck %s --check-prefix=AVX2
   4
   5 ; Don't generate an unaligned 32-byte load on this test if that is slower than two 16-byte loads.
   6
   7 define <8 x float> @load32bytes(<8 x float>* %Ap) {
   8 ; AVXSLOW-LABEL: load32bytes:
   9 ; AVXSLOW:       # BB#0:
  10 ; AVXSLOW-NEXT:    vmovaps (%rdi), %xmm0
  11 ; AVXSLOW-NEXT:    vinsertf128 $1, 16(%rdi), %ymm0, %ymm0
  12 ; AVXSLOW-NEXT:    retq
  13 ;
  14 ; AVXFAST-LABEL: load32bytes:
  15 ; AVXFAST:       # BB#0:
  16 ; AVXFAST-NEXT:    vmovups (%rdi), %ymm0
  17 ; AVXFAST-NEXT:    retq
  18 ;
  19 ; AVX2-LABEL: load32bytes:
  20 ; AVX2:       # BB#0:
  21 ; AVX2-NEXT:    vmovups (%rdi), %ymm0
  22 ; AVX2-NEXT:    retq
  23   %A = load <8 x float>, <8 x float>* %Ap, align 16
  24   ret <8 x float> %A
  25 }
  26
  27 ; Don't generate an unaligned 32-byte store on this test if that is slower than two 16-byte loads.
  28
  29 define void @store32bytes(<8 x float> %A, <8 x float>* %P) {
  30 ; AVXSLOW-LABEL: store32bytes:
  31 ; AVXSLOW:       # BB#0:
  32 ; AVXSLOW-NEXT:    vextractf128 $1, %ymm0, 16(%rdi)
  33 ; AVXSLOW-NEXT:    vmovaps %xmm0, (%rdi)
  34 ; AVXSLOW-NEXT:    vzeroupper
  35 ; AVXSLOW-NEXT:    retq
  36 ;
  37 ; AVXFAST-LABEL: store32bytes:
  38 ; AVXFAST:       # BB#0:
  39 ; AVXFAST-NEXT:    vmovups %ymm0, (%rdi)
  40 ; AVXFAST-NEXT:    vzeroupper
  41 ; AVXFAST-NEXT:    retq
  42 ;
  43 ; AVX2-LABEL: store32bytes:
  44 ; AVX2:       # BB#0:
  45 ; AVX2-NEXT:    vmovups %ymm0, (%rdi)
  46 ; AVX2-NEXT:    vzeroupper
  47 ; AVX2-NEXT:    retq
  48   store <8 x float> %A, <8 x float>* %P, align 16
  49   ret void
  50 }
  51
  52 ; Merge two consecutive 16-byte subvector loads into a single 32-byte load if it's faster.
  53
  54 define <8 x float> @combine_16_byte_loads_no_intrinsic(<4 x float>* %ptr) {
  55 ; AVXSLOW-LABEL: combine_16_byte_loads_no_intrinsic:
  56 ; AVXSLOW:       # BB#0:
  57 ; AVXSLOW-NEXT:    vmovups 48(%rdi), %xmm0
  58 ; AVXSLOW-NEXT:    vinsertf128 $1, 64(%rdi), %ymm0, %ymm0
  59 ; AVXSLOW-NEXT:    retq
  60 ;
  61 ; AVXFAST-LABEL: combine_16_byte_loads_no_intrinsic:
  62 ; AVXFAST:       # BB#0:
  63 ; AVXFAST-NEXT:    vmovups 48(%rdi), %ymm0
  64 ; AVXFAST-NEXT:    retq
  65 ;
  66 ; AVX2-LABEL: combine_16_byte_loads_no_intrinsic:
  67 ; AVX2:       # BB#0:
  68 ; AVX2-NEXT:    vmovups 48(%rdi), %ymm0
  69 ; AVX2-NEXT:    retq
  70   %ptr1 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 3
  71   %ptr2 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 4
  72   %v1 = load <4 x float>, <4 x float>* %ptr1, align 1
  73   %v2 = load <4 x float>, <4 x float>* %ptr2, align 1
  74   %v3 = shufflevector <4 x float> %v1, <4 x float> %v2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
  75   ret <8 x float> %v3
  76 }
  77
  78 ; If the first load is 32-byte aligned, then the loads should be merged in all cases.
  79
  80 define <8 x float> @combine_16_byte_loads_aligned(<4 x float>* %ptr) {
  81 ; AVXSLOW-LABEL: combine_16_byte_loads_aligned:
  82 ; AVXSLOW:       # BB#0:
  83 ; AVXSLOW-NEXT:    vmovaps 48(%rdi), %ymm0
  84 ; AVXSLOW-NEXT:    retq
  85 ;
  86 ; AVXFAST-LABEL: combine_16_byte_loads_aligned:
  87 ; AVXFAST:       # BB#0:
  88 ; AVXFAST-NEXT:    vmovaps 48(%rdi), %ymm0
  89 ; AVXFAST-NEXT:    retq
  90 ;
  91 ; AVX2-LABEL: combine_16_byte_loads_aligned:
  92 ; AVX2:       # BB#0:
  93 ; AVX2-NEXT:    vmovaps 48(%rdi), %ymm0
  94 ; AVX2-NEXT:    retq
  95   %ptr1 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 3
  96   %ptr2 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 4
  97   %v1 = load <4 x float>, <4 x float>* %ptr1, align 32
  98   %v2 = load <4 x float>, <4 x float>* %ptr2, align 1
  99   %v3 = shufflevector <4 x float> %v1, <4 x float> %v2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 100   ret <8 x float> %v3
 101 }
 102
 103 ; Swap the order of the shufflevector operands to ensure that the pattern still matches.
 104
 105 define <8 x float> @combine_16_byte_loads_no_intrinsic_swap(<4 x float>* %ptr) {
 106 ; AVXSLOW-LABEL: combine_16_byte_loads_no_intrinsic_swap:
 107 ; AVXSLOW:       # BB#0:
 108 ; AVXSLOW-NEXT:    vmovups 64(%rdi), %xmm0
 109 ; AVXSLOW-NEXT:    vinsertf128 $1, 80(%rdi), %ymm0, %ymm0
 110 ; AVXSLOW-NEXT:    retq
 111 ;
 112 ; AVXFAST-LABEL: combine_16_byte_loads_no_intrinsic_swap:
 113 ; AVXFAST:       # BB#0:
 114 ; AVXFAST-NEXT:    vmovups 64(%rdi), %ymm0
 115 ; AVXFAST-NEXT:    retq
 116 ;
 117 ; AVX2-LABEL: combine_16_byte_loads_no_intrinsic_swap:
 118 ; AVX2:       # BB#0:
 119 ; AVX2-NEXT:    vmovups 64(%rdi), %ymm0
 120 ; AVX2-NEXT:    retq
 121   %ptr1 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 4
 122   %ptr2 = getelementptr inbounds <4 x float>, <4 x float>* %ptr, i64 5
 123   %v1 = load <4 x float>, <4 x float>* %ptr1, align 1
 124   %v2 = load <4 x float>, <4 x float>* %ptr2, align 1
 125   %v3 = shufflevector <4 x float> %v2, <4 x float> %v1, <8 x i32> <i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3>
 126   ret <8 x float> %v3
 127 }
 128
 129 ; Check each element type other than float to make sure it is handled correctly.
 130 ; Use the loaded values with an 'add' to make sure we're using the correct load type.
 131 ; Don't generate 32-byte loads for integer ops unless we have AVX2.
 132
 133 define <4 x i64> @combine_16_byte_loads_i64(<2 x i64>* %ptr, <4 x i64> %x) {
 134 ; AVXSLOW-LABEL: combine_16_byte_loads_i64:
 135 ; AVXSLOW:       # BB#0:
 136 ; AVXSLOW-NEXT:    vextractf128 $1, %ymm0, %xmm1
 137 ; AVXSLOW-NEXT:    vpaddq 96(%rdi), %xmm1, %xmm1
 138 ; AVXSLOW-NEXT:    vpaddq 80(%rdi), %xmm0, %xmm0
 139 ; AVXSLOW-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 140 ; AVXSLOW-NEXT:    retq
 141 ;
 142 ; AVXFAST-LABEL: combine_16_byte_loads_i64:
 143 ; AVXFAST:       # BB#0:
 144 ; AVXFAST-NEXT:    vextractf128 $1, %ymm0, %xmm1
 145 ; AVXFAST-NEXT:    vpaddq 96(%rdi), %xmm1, %xmm1
 146 ; AVXFAST-NEXT:    vpaddq 80(%rdi), %xmm0, %xmm0
 147 ; AVXFAST-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 148 ; AVXFAST-NEXT:    retq
 149 ;
 150 ; AVX2-LABEL: combine_16_byte_loads_i64:
 151 ; AVX2:       # BB#0:
 152 ; AVX2-NEXT:    vpaddq 80(%rdi), %ymm0, %ymm0
 153 ; AVX2-NEXT:    retq
 154   %ptr1 = getelementptr inbounds <2 x i64>, <2 x i64>* %ptr, i64 5
 155   %ptr2 = getelementptr inbounds <2 x i64>, <2 x i64>* %ptr, i64 6
 156   %v1 = load <2 x i64>, <2 x i64>* %ptr1, align 1
 157   %v2 = load <2 x i64>, <2 x i64>* %ptr2, align 1
 158   %v3 = shufflevector <2 x i64> %v1, <2 x i64> %v2, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 159   %v4 = add <4 x i64> %v3, %x
 160   ret <4 x i64> %v4
 161 }
 162
 163 define <8 x i32> @combine_16_byte_loads_i32(<4 x i32>* %ptr, <8 x i32> %x) {
 164 ; AVXSLOW-LABEL: combine_16_byte_loads_i32:
 165 ; AVXSLOW:       # BB#0:
 166 ; AVXSLOW-NEXT:    vextractf128 $1, %ymm0, %xmm1
 167 ; AVXSLOW-NEXT:    vpaddd 112(%rdi), %xmm1, %xmm1
 168 ; AVXSLOW-NEXT:    vpaddd 96(%rdi), %xmm0, %xmm0
 169 ; AVXSLOW-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 170 ; AVXSLOW-NEXT:    retq
 171 ;
 172 ; AVXFAST-LABEL: combine_16_byte_loads_i32:
 173 ; AVXFAST:       # BB#0:
 174 ; AVXFAST-NEXT:    vextractf128 $1, %ymm0, %xmm1
 175 ; AVXFAST-NEXT:    vpaddd 112(%rdi), %xmm1, %xmm1
 176 ; AVXFAST-NEXT:    vpaddd 96(%rdi), %xmm0, %xmm0
 177 ; AVXFAST-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 178 ; AVXFAST-NEXT:    retq
 179 ;
 180 ; AVX2-LABEL: combine_16_byte_loads_i32:
 181 ; AVX2:       # BB#0:
 182 ; AVX2-NEXT:    vpaddd 96(%rdi), %ymm0, %ymm0
 183 ; AVX2-NEXT:    retq
 184   %ptr1 = getelementptr inbounds <4 x i32>, <4 x i32>* %ptr, i64 6
 185   %ptr2 = getelementptr inbounds <4 x i32>, <4 x i32>* %ptr, i64 7
 186   %v1 = load <4 x i32>, <4 x i32>* %ptr1, align 1
 187   %v2 = load <4 x i32>, <4 x i32>* %ptr2, align 1
 188   %v3 = shufflevector <4 x i32> %v1, <4 x i32> %v2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 189   %v4 = add <8 x i32> %v3, %x
 190   ret <8 x i32> %v4
 191 }
 192
 193 define <16 x i16> @combine_16_byte_loads_i16(<8 x i16>* %ptr, <16 x i16> %x) {
 194 ; AVXSLOW-LABEL: combine_16_byte_loads_i16:
 195 ; AVXSLOW:       # BB#0:
 196 ; AVXSLOW-NEXT:    vextractf128 $1, %ymm0, %xmm1
 197 ; AVXSLOW-NEXT:    vpaddw 128(%rdi), %xmm1, %xmm1
 198 ; AVXSLOW-NEXT:    vpaddw 112(%rdi), %xmm0, %xmm0
 199 ; AVXSLOW-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 200 ; AVXSLOW-NEXT:    retq
 201 ;
 202 ; AVXFAST-LABEL: combine_16_byte_loads_i16:
 203 ; AVXFAST:       # BB#0:
 204 ; AVXFAST-NEXT:    vextractf128 $1, %ymm0, %xmm1
 205 ; AVXFAST-NEXT:    vpaddw 128(%rdi), %xmm1, %xmm1
 206 ; AVXFAST-NEXT:    vpaddw 112(%rdi), %xmm0, %xmm0
 207 ; AVXFAST-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 208 ; AVXFAST-NEXT:    retq
 209 ;
 210 ; AVX2-LABEL: combine_16_byte_loads_i16:
 211 ; AVX2:       # BB#0:
 212 ; AVX2-NEXT:    vpaddw 112(%rdi), %ymm0, %ymm0
 213 ; AVX2-NEXT:    retq
 214   %ptr1 = getelementptr inbounds <8 x i16>, <8 x i16>* %ptr, i64 7
 215   %ptr2 = getelementptr inbounds <8 x i16>, <8 x i16>* %ptr, i64 8
 216   %v1 = load <8 x i16>, <8 x i16>* %ptr1, align 1
 217   %v2 = load <8 x i16>, <8 x i16>* %ptr2, align 1
 218   %v3 = shufflevector <8 x i16> %v1, <8 x i16> %v2, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 219   %v4 = add <16 x i16> %v3, %x
 220   ret <16 x i16> %v4
 221 }
 222
 223 define <32 x i8> @combine_16_byte_loads_i8(<16 x i8>* %ptr, <32 x i8> %x) {
 224 ; AVXSLOW-LABEL: combine_16_byte_loads_i8:
 225 ; AVXSLOW:       # BB#0:
 226 ; AVXSLOW-NEXT:    vextractf128 $1, %ymm0, %xmm1
 227 ; AVXSLOW-NEXT:    vpaddb 144(%rdi), %xmm1, %xmm1
 228 ; AVXSLOW-NEXT:    vpaddb 128(%rdi), %xmm0, %xmm0
 229 ; AVXSLOW-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 230 ; AVXSLOW-NEXT:    retq
 231 ;
 232 ; AVXFAST-LABEL: combine_16_byte_loads_i8:
 233 ; AVXFAST:       # BB#0:
 234 ; AVXFAST-NEXT:    vextractf128 $1, %ymm0, %xmm1
 235 ; AVXFAST-NEXT:    vpaddb 144(%rdi), %xmm1, %xmm1
 236 ; AVXFAST-NEXT:    vpaddb 128(%rdi), %xmm0, %xmm0
 237 ; AVXFAST-NEXT:    vinsertf128 $1, %xmm1, %ymm0, %ymm0
 238 ; AVXFAST-NEXT:    retq
 239 ;
 240 ; AVX2-LABEL: combine_16_byte_loads_i8:
 241 ; AVX2:       # BB#0:
 242 ; AVX2-NEXT:    vpaddb 128(%rdi), %ymm0, %ymm0
 243 ; AVX2-NEXT:    retq
 244   %ptr1 = getelementptr inbounds <16 x i8>, <16 x i8>* %ptr, i64 8
 245   %ptr2 = getelementptr inbounds <16 x i8>, <16 x i8>* %ptr, i64 9
 246   %v1 = load <16 x i8>, <16 x i8>* %ptr1, align 1
 247   %v2 = load <16 x i8>, <16 x i8>* %ptr2, align 1
 248   %v3 = shufflevector <16 x i8> %v1, <16 x i8> %v2, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
 249   %v4 = add <32 x i8> %v3, %x
 250   ret <32 x i8> %v4
 251 }
 252
 253 define <4 x double> @combine_16_byte_loads_double(<2 x double>* %ptr, <4 x double> %x) {
 254 ; AVXSLOW-LABEL: combine_16_byte_loads_double:
 255 ; AVXSLOW:       # BB#0:
 256 ; AVXSLOW-NEXT:    vmovupd 144(%rdi), %xmm1
 257 ; AVXSLOW-NEXT:    vinsertf128 $1, 160(%rdi), %ymm1, %ymm1
 258 ; AVXSLOW-NEXT:    vaddpd %ymm0, %ymm1, %ymm0
 259 ; AVXSLOW-NEXT:    retq
 260 ;
 261 ; AVXFAST-LABEL: combine_16_byte_loads_double:
 262 ; AVXFAST:       # BB#0:
 263 ; AVXFAST-NEXT:    vaddpd 144(%rdi), %ymm0, %ymm0
 264 ; AVXFAST-NEXT:    retq
 265 ;
 266 ; AVX2-LABEL: combine_16_byte_loads_double:
 267 ; AVX2:       # BB#0:
 268 ; AVX2-NEXT:    vaddpd 144(%rdi), %ymm0, %ymm0
 269 ; AVX2-NEXT:    retq
 270   %ptr1 = getelementptr inbounds <2 x double>, <2 x double>* %ptr, i64 9
 271   %ptr2 = getelementptr inbounds <2 x double>, <2 x double>* %ptr, i64 10
 272   %v1 = load <2 x double>, <2 x double>* %ptr1, align 1
 273   %v2 = load <2 x double>, <2 x double>* %ptr2, align 1
 274   %v3 = shufflevector <2 x double> %v1, <2 x double> %v2, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 275   %v4 = fadd <4 x double> %v3, %x
 276   ret <4 x double> %v4
 277 }
 278