llvm/test/Transforms/VectorCombine/X86/load.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes=vector-combine -S -mtriple=x86_64-- -mattr=sse2 | FileCheck %s --check-prefixes=CHECK,SSE2
   3 ; RUN: opt < %s -passes=vector-combine -S -mtriple=x86_64-- -mattr=avx2 | FileCheck %s --check-prefixes=CHECK,AVX2
   4
   5 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   6
   7 define float @matching_fp_scalar(ptr align 16 dereferenceable(16) %p) {
   8 ; CHECK-LABEL: @matching_fp_scalar(
   9 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
  10 ; CHECK-NEXT:    ret float [[R]]
  11 ;
  12   %r = load float, ptr %p, align 16
  13   ret float %r
  14 }
  15
  16 define float @matching_fp_scalar_volatile(ptr align 16 dereferenceable(16) %p) {
  17 ; CHECK-LABEL: @matching_fp_scalar_volatile(
  18 ; CHECK-NEXT:    [[R:%.*]] = load volatile float, ptr [[P:%.*]], align 16
  19 ; CHECK-NEXT:    ret float [[R]]
  20 ;
  21   %r = load volatile float, ptr %p, align 16
  22   ret float %r
  23 }
  24
  25 define double @larger_fp_scalar(ptr align 16 dereferenceable(16) %p) {
  26 ; CHECK-LABEL: @larger_fp_scalar(
  27 ; CHECK-NEXT:    [[R:%.*]] = load double, ptr [[P:%.*]], align 16
  28 ; CHECK-NEXT:    ret double [[R]]
  29 ;
  30   %r = load double, ptr %p, align 16
  31   ret double %r
  32 }
  33
  34 define float @smaller_fp_scalar(ptr align 16 dereferenceable(16) %p) {
  35 ; CHECK-LABEL: @smaller_fp_scalar(
  36 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
  37 ; CHECK-NEXT:    ret float [[R]]
  38 ;
  39   %r = load float, ptr %p, align 16
  40   ret float %r
  41 }
  42
  43 define float @matching_fp_vector(ptr align 16 dereferenceable(16) %p) {
  44 ; CHECK-LABEL: @matching_fp_vector(
  45 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
  46 ; CHECK-NEXT:    ret float [[R]]
  47 ;
  48   %r = load float, ptr %p, align 16
  49   ret float %r
  50 }
  51
  52 define float @matching_fp_vector_gep00(ptr align 16 dereferenceable(16) %p) {
  53 ; CHECK-LABEL: @matching_fp_vector_gep00(
  54 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
  55 ; CHECK-NEXT:    ret float [[R]]
  56 ;
  57   %r = load float, ptr %p, align 16
  58   ret float %r
  59 }
  60
  61 define float @matching_fp_vector_gep01(ptr align 16 dereferenceable(20) %p) {
  62 ; CHECK-LABEL: @matching_fp_vector_gep01(
  63 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <4 x float>, ptr [[P:%.*]], i64 0, i64 1
  64 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[GEP]], align 4
  65 ; CHECK-NEXT:    ret float [[R]]
  66 ;
  67   %gep = getelementptr inbounds <4 x float>, ptr %p, i64 0, i64 1
  68   %r = load float, ptr %gep, align 4
  69   ret float %r
  70 }
  71
  72 define float @matching_fp_vector_gep01_deref(ptr align 16 dereferenceable(19) %p) {
  73 ; CHECK-LABEL: @matching_fp_vector_gep01_deref(
  74 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <4 x float>, ptr [[P:%.*]], i64 0, i64 1
  75 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[GEP]], align 4
  76 ; CHECK-NEXT:    ret float [[R]]
  77 ;
  78   %gep = getelementptr inbounds <4 x float>, ptr %p, i64 0, i64 1
  79   %r = load float, ptr %gep, align 4
  80   ret float %r
  81 }
  82
  83 define float @matching_fp_vector_gep10(ptr align 16 dereferenceable(32) %p) {
  84 ; CHECK-LABEL: @matching_fp_vector_gep10(
  85 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <4 x float>, ptr [[P:%.*]], i64 1, i64 0
  86 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[GEP]], align 16
  87 ; CHECK-NEXT:    ret float [[R]]
  88 ;
  89   %gep = getelementptr inbounds <4 x float>, ptr %p, i64 1, i64 0
  90   %r = load float, ptr %gep, align 16
  91   ret float %r
  92 }
  93
  94 define float @matching_fp_vector_gep10_deref(ptr align 16 dereferenceable(31) %p) {
  95 ; CHECK-LABEL: @matching_fp_vector_gep10_deref(
  96 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <4 x float>, ptr [[P:%.*]], i64 1, i64 0
  97 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[GEP]], align 16
  98 ; CHECK-NEXT:    ret float [[R]]
  99 ;
 100   %gep = getelementptr inbounds <4 x float>, ptr %p, i64 1, i64 0
 101   %r = load float, ptr %gep, align 16
 102   ret float %r
 103 }
 104
 105 define float @nonmatching_int_vector(ptr align 16 dereferenceable(16) %p) {
 106 ; CHECK-LABEL: @nonmatching_int_vector(
 107 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
 108 ; CHECK-NEXT:    ret float [[R]]
 109 ;
 110   %r = load float, ptr %p, align 16
 111   ret float %r
 112 }
 113
 114 define double @less_aligned(ptr align 4 dereferenceable(16) %p) {
 115 ; CHECK-LABEL: @less_aligned(
 116 ; CHECK-NEXT:    [[R:%.*]] = load double, ptr [[P:%.*]], align 4
 117 ; CHECK-NEXT:    ret double [[R]]
 118 ;
 119   %r = load double, ptr %p, align 4
 120   ret double %r
 121 }
 122
 123 define float @matching_fp_scalar_small_deref(ptr align 16 dereferenceable(15) %p) {
 124 ; CHECK-LABEL: @matching_fp_scalar_small_deref(
 125 ; CHECK-NEXT:    [[R:%.*]] = load float, ptr [[P:%.*]], align 16
 126 ; CHECK-NEXT:    ret float [[R]]
 127 ;
 128   %r = load float, ptr %p, align 16
 129   ret float %r
 130 }
 131
 132 define i64 @larger_int_scalar(ptr align 16 dereferenceable(16) %p) {
 133 ; CHECK-LABEL: @larger_int_scalar(
 134 ; CHECK-NEXT:    [[R:%.*]] = load i64, ptr [[P:%.*]], align 16
 135 ; CHECK-NEXT:    ret i64 [[R]]
 136 ;
 137   %r = load i64, ptr %p, align 16
 138   ret i64 %r
 139 }
 140
 141 define i8 @smaller_int_scalar(ptr align 16 dereferenceable(16) %p) {
 142 ; CHECK-LABEL: @smaller_int_scalar(
 143 ; CHECK-NEXT:    [[R:%.*]] = load i8, ptr [[P:%.*]], align 16
 144 ; CHECK-NEXT:    ret i8 [[R]]
 145 ;
 146   %r = load i8, ptr %p, align 16
 147   ret i8 %r
 148 }
 149
 150 define double @larger_fp_scalar_256bit_vec(ptr align 32 dereferenceable(32) %p) {
 151 ; CHECK-LABEL: @larger_fp_scalar_256bit_vec(
 152 ; CHECK-NEXT:    [[R:%.*]] = load double, ptr [[P:%.*]], align 32
 153 ; CHECK-NEXT:    ret double [[R]]
 154 ;
 155   %r = load double, ptr %p, align 32
 156   ret double %r
 157 }
 158
 159 define <4 x float> @load_f32_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 160 ; CHECK-LABEL: @load_f32_insert_v4f32(
 161 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 162 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 163 ; CHECK-NEXT:    ret <4 x float> [[R]]
 164 ;
 165   %s = load float, ptr %p, align 4
 166   %r = insertelement <4 x float> undef, float %s, i32 0
 167   ret <4 x float> %r
 168 }
 169
 170 define <4 x float> @casted_load_f32_insert_v4f32(ptr align 4 dereferenceable(16) %p) nofree nosync {
 171 ; CHECK-LABEL: @casted_load_f32_insert_v4f32(
 172 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 4
 173 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 174 ; CHECK-NEXT:    ret <4 x float> [[R]]
 175 ;
 176   %s = load float, ptr %p, align 4
 177   %r = insertelement <4 x float> undef, float %s, i32 0
 178   ret <4 x float> %r
 179 }
 180
 181 ; Element type does not change cost.
 182
 183 define <4 x i32> @load_i32_insert_v4i32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 184 ; CHECK-LABEL: @load_i32_insert_v4i32(
 185 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 16
 186 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 187 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 188 ;
 189   %s = load i32, ptr %p, align 4
 190   %r = insertelement <4 x i32> undef, i32 %s, i32 0
 191   ret <4 x i32> %r
 192 }
 193
 194 ; Pointer type does not change cost.
 195
 196 define <4 x i32> @casted_load_i32_insert_v4i32(ptr align 4 dereferenceable(16) %p) nofree nosync {
 197 ; CHECK-LABEL: @casted_load_i32_insert_v4i32(
 198 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 4
 199 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 200 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 201 ;
 202   %s = load i32, ptr %p, align 4
 203   %r = insertelement <4 x i32> undef, i32 %s, i32 0
 204   ret <4 x i32> %r
 205 }
 206
 207 ; This is canonical form for vector element access.
 208
 209 define <4 x float> @gep00_load_f32_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 210 ; CHECK-LABEL: @gep00_load_f32_insert_v4f32(
 211 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 212 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 213 ; CHECK-NEXT:    ret <4 x float> [[R]]
 214 ;
 215   %s = load float, ptr %p, align 16
 216   %r = insertelement <4 x float> undef, float %s, i64 0
 217   ret <4 x float> %r
 218 }
 219
 220 ; Should work with addrspace as well.
 221
 222 define <4 x float> @gep00_load_f32_insert_v4f32_addrspace(ptr addrspace(44) align 16 dereferenceable(16) %p) nofree nosync {
 223 ; CHECK-LABEL: @gep00_load_f32_insert_v4f32_addrspace(
 224 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr addrspace(44) [[P:%.*]], align 16
 225 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 226 ; CHECK-NEXT:    ret <4 x float> [[R]]
 227 ;
 228   %s = load float, ptr addrspace(44) %p, align 16
 229   %r = insertelement <4 x float> undef, float %s, i64 0
 230   ret <4 x float> %r
 231 }
 232
 233 ; If there are enough dereferenceable bytes, we can offset the vector load.
 234
 235 define <8 x i16> @gep01_load_i16_insert_v8i16(ptr align 16 dereferenceable(18) %p) nofree nosync {
 236 ; CHECK-LABEL: @gep01_load_i16_insert_v8i16(
 237 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 238 ; CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[GEP]], align 2
 239 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <8 x i16> [[TMP1]], <8 x i16> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 240 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 241 ;
 242   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 243   %s = load i16, ptr %gep, align 2
 244   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 245   ret <8 x i16> %r
 246 }
 247
 248 ; Can't safely load the offset vector, but can load+shuffle if it is profitable.
 249
 250 define <8 x i16> @gep01_load_i16_insert_v8i16_deref(ptr align 16 dereferenceable(17) %p) nofree nosync {
 251 ; SSE2-LABEL: @gep01_load_i16_insert_v8i16_deref(
 252 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 253 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 2
 254 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 255 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 256 ;
 257 ; AVX2-LABEL: @gep01_load_i16_insert_v8i16_deref(
 258 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 16
 259 ; AVX2-NEXT:    [[R:%.*]] = shufflevector <8 x i16> [[TMP1]], <8 x i16> poison, <8 x i32> <i32 1, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 260 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 261 ;
 262   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 263   %s = load i16, ptr %gep, align 2
 264   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 265   ret <8 x i16> %r
 266 }
 267
 268 ; Verify that alignment of the new load is not over-specified.
 269
 270 define <8 x i16> @gep01_load_i16_insert_v8i16_deref_minalign(ptr align 2 dereferenceable(16) %p) nofree nosync {
 271 ; SSE2-LABEL: @gep01_load_i16_insert_v8i16_deref_minalign(
 272 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 273 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 8
 274 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 275 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 276 ;
 277 ; AVX2-LABEL: @gep01_load_i16_insert_v8i16_deref_minalign(
 278 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 2
 279 ; AVX2-NEXT:    [[R:%.*]] = shufflevector <8 x i16> [[TMP1]], <8 x i16> poison, <8 x i32> <i32 1, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 280 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 281 ;
 282   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 283   %s = load i16, ptr %gep, align 8
 284   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 285   ret <8 x i16> %r
 286 }
 287
 288 ; Negative test - if we are shuffling a load from the base pointer, the address offset
 289 ; must be a multiple of element size.
 290 ; TODO: Could bitcast around this limitation.
 291
 292 define <4 x i32> @gep01_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(16) %p) {
 293 ; CHECK-LABEL: @gep01_bitcast_load_i32_insert_v4i32(
 294 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <16 x i8>, ptr [[P:%.*]], i64 0, i64 1
 295 ; CHECK-NEXT:    [[S:%.*]] = load i32, ptr [[GEP]], align 1
 296 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x i32> undef, i32 [[S]], i64 0
 297 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 298 ;
 299   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 1
 300   %s = load i32, ptr %gep, align 1
 301   %r = insertelement <4 x i32> undef, i32 %s, i64 0
 302   ret <4 x i32> %r
 303 }
 304
 305 define <4 x i32> @gep012_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(20) %p) nofree nosync {
 306 ; CHECK-LABEL: @gep012_bitcast_load_i32_insert_v4i32(
 307 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 1
 308 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <4 x i32> <i32 3, i32 poison, i32 poison, i32 poison>
 309 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 310 ;
 311   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 12
 312   %s = load i32, ptr %gep, align 1
 313   %r = insertelement <4 x i32> undef, i32 %s, i64 0
 314   ret <4 x i32> %r
 315 }
 316
 317 ; Negative test - if we are shuffling a load from the base pointer, the address offset
 318 ; must be a multiple of element size and the offset must be low enough to fit in the vector
 319 ; (bitcasting would not help this case).
 320
 321 define <4 x i32> @gep013_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(20) %p) nofree nosync {
 322 ; CHECK-LABEL: @gep013_bitcast_load_i32_insert_v4i32(
 323 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <16 x i8>, ptr [[P:%.*]], i64 0, i64 13
 324 ; CHECK-NEXT:    [[S:%.*]] = load i32, ptr [[GEP]], align 1
 325 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x i32> undef, i32 [[S]], i64 0
 326 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 327 ;
 328   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 13
 329   %s = load i32, ptr %gep, align 1
 330   %r = insertelement <4 x i32> undef, i32 %s, i64 0
 331   ret <4 x i32> %r
 332 }
 333
 334 ; If there are enough dereferenceable bytes, we can offset the vector load.
 335
 336 define <8 x i16> @gep10_load_i16_insert_v8i16(ptr align 16 dereferenceable(32) %p) nofree nosync {
 337 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16(
 338 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 339 ; CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[GEP]], align 16
 340 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <8 x i16> [[TMP1]], <8 x i16> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 341 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 342 ;
 343   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 344   %s = load i16, ptr %gep, align 16
 345   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 346   ret <8 x i16> %r
 347 }
 348
 349 ; Negative test - disable under asan because widened load can cause spurious
 350 ; use-after-poison issues when __asan_poison_memory_region is used.
 351
 352 define <8 x i16> @gep10_load_i16_insert_v8i16_asan(ptr align 16 dereferenceable(32) %p) sanitize_address nofree nosync {
 353 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_asan(
 354 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 355 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 356 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 357 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 358 ;
 359   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 360   %s = load i16, ptr %gep, align 16
 361   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 362   ret <8 x i16> %r
 363 }
 364
 365 ; hwasan and memtag should be similarly suppressed.
 366
 367 define <8 x i16> @gep10_load_i16_insert_v8i16_hwasan(ptr align 16 dereferenceable(32) %p) sanitize_hwaddress nofree nosync {
 368 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_hwasan(
 369 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 370 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 371 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 372 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 373 ;
 374   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 375   %s = load i16, ptr %gep, align 16
 376   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 377   ret <8 x i16> %r
 378 }
 379
 380 define <8 x i16> @gep10_load_i16_insert_v8i16_memtag(ptr align 16 dereferenceable(32) %p) sanitize_memtag nofree nosync {
 381 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_memtag(
 382 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 383 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 384 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 385 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 386 ;
 387   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 388   %s = load i16, ptr %gep, align 16
 389   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 390   ret <8 x i16> %r
 391 }
 392
 393 ; Negative test - disable under tsan because widened load may overlap bytes
 394 ; being concurrently modified. tsan does not know that some bytes are undef.
 395
 396 define <8 x i16> @gep10_load_i16_insert_v8i16_tsan(ptr align 16 dereferenceable(32) %p) sanitize_thread nofree nosync {
 397 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_tsan(
 398 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 399 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 400 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 401 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 402 ;
 403   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 404   %s = load i16, ptr %gep, align 16
 405   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 406   ret <8 x i16> %r
 407 }
 408
 409 ; Negative test - can't safely load the offset vector, but could load+shuffle.
 410
 411 define <8 x i16> @gep10_load_i16_insert_v8i16_deref(ptr align 16 dereferenceable(31) %p) nofree nosync {
 412 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_deref(
 413 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 414 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 415 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 416 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 417 ;
 418   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 419   %s = load i16, ptr %gep, align 16
 420   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 421   ret <8 x i16> %r
 422 }
 423
 424 ; Negative test - do not alter volatile.
 425
 426 define <4 x float> @load_f32_insert_v4f32_volatile(ptr align 16 dereferenceable(16) %p) nofree nosync {
 427 ; CHECK-LABEL: @load_f32_insert_v4f32_volatile(
 428 ; CHECK-NEXT:    [[S:%.*]] = load volatile float, ptr [[P:%.*]], align 4
 429 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> undef, float [[S]], i32 0
 430 ; CHECK-NEXT:    ret <4 x float> [[R]]
 431 ;
 432   %s = load volatile float, ptr %p, align 4
 433   %r = insertelement <4 x float> undef, float %s, i32 0
 434   ret <4 x float> %r
 435 }
 436
 437 ; Pointer is not as aligned as load, but that's ok.
 438 ; The new load uses the larger alignment value.
 439
 440 define <4 x float> @load_f32_insert_v4f32_align(ptr align 1 dereferenceable(16) %p) nofree nosync {
 441 ; CHECK-LABEL: @load_f32_insert_v4f32_align(
 442 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 4
 443 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 444 ; CHECK-NEXT:    ret <4 x float> [[R]]
 445 ;
 446   %s = load float, ptr %p, align 4
 447   %r = insertelement <4 x float> undef, float %s, i32 0
 448   ret <4 x float> %r
 449 }
 450
 451 ; Negative test - not enough bytes.
 452
 453 define <4 x float> @load_f32_insert_v4f32_deref(ptr align 4 dereferenceable(15) %p) nofree nosync {
 454 ; CHECK-LABEL: @load_f32_insert_v4f32_deref(
 455 ; CHECK-NEXT:    [[S:%.*]] = load float, ptr [[P:%.*]], align 4
 456 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> undef, float [[S]], i32 0
 457 ; CHECK-NEXT:    ret <4 x float> [[R]]
 458 ;
 459   %s = load float, ptr %p, align 4
 460   %r = insertelement <4 x float> undef, float %s, i32 0
 461   ret <4 x float> %r
 462 }
 463
 464 define <8 x i32> @load_i32_insert_v8i32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 465 ; CHECK-LABEL: @load_i32_insert_v8i32(
 466 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 16
 467 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 468 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 469 ;
 470   %s = load i32, ptr %p, align 4
 471   %r = insertelement <8 x i32> undef, i32 %s, i32 0
 472   ret <8 x i32> %r
 473 }
 474
 475 define <8 x i32> @casted_load_i32_insert_v8i32(ptr align 4 dereferenceable(16) %p) nofree nosync {
 476 ; CHECK-LABEL: @casted_load_i32_insert_v8i32(
 477 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 4
 478 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <8 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 479 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 480 ;
 481   %s = load i32, ptr %p, align 4
 482   %r = insertelement <8 x i32> undef, i32 %s, i32 0
 483   ret <8 x i32> %r
 484 }
 485
 486 define <16 x float> @load_f32_insert_v16f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 487 ; CHECK-LABEL: @load_f32_insert_v16f32(
 488 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 489 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <16 x i32> <i32 0, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 490 ; CHECK-NEXT:    ret <16 x float> [[R]]
 491 ;
 492   %s = load float, ptr %p, align 4
 493   %r = insertelement <16 x float> undef, float %s, i32 0
 494   ret <16 x float> %r
 495 }
 496
 497 define <2 x float> @load_f32_insert_v2f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 498 ; CHECK-LABEL: @load_f32_insert_v2f32(
 499 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 500 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <2 x i32> <i32 0, i32 poison>
 501 ; CHECK-NEXT:    ret <2 x float> [[R]]
 502 ;
 503   %s = load float, ptr %p, align 4
 504   %r = insertelement <2 x float> undef, float %s, i32 0
 505   ret <2 x float> %r
 506 }
 507
 508 ; Negative test - suppress load widening for asan/hwasan/memtag/tsan.
 509
 510 define <2 x float> @load_f32_insert_v2f32_asan(ptr align 16 dereferenceable(16) %p) sanitize_address {
 511 ; CHECK-LABEL: @load_f32_insert_v2f32_asan(
 512 ; CHECK-NEXT:    [[S:%.*]] = load float, ptr [[P:%.*]], align 4
 513 ; CHECK-NEXT:    [[R:%.*]] = insertelement <2 x float> undef, float [[S]], i32 0
 514 ; CHECK-NEXT:    ret <2 x float> [[R]]
 515 ;
 516   %s = load float, ptr %p, align 4
 517   %r = insertelement <2 x float> undef, float %s, i32 0
 518   ret <2 x float> %r
 519 }
 520
 521 declare ptr @getscaleptr()
 522 define void @PR47558_multiple_use_load(ptr nocapture nonnull %resultptr, ptr nocapture nonnull readonly %opptr) {
 523 ; CHECK-LABEL: @PR47558_multiple_use_load(
 524 ; CHECK-NEXT:    [[SCALEPTR:%.*]] = tail call nonnull align 16 dereferenceable(64) ptr @getscaleptr()
 525 ; CHECK-NEXT:    [[OP:%.*]] = load <2 x float>, ptr [[OPPTR:%.*]], align 4
 526 ; CHECK-NEXT:    [[SCALE:%.*]] = load float, ptr [[SCALEPTR]], align 16
 527 ; CHECK-NEXT:    [[T1:%.*]] = insertelement <2 x float> undef, float [[SCALE]], i32 0
 528 ; CHECK-NEXT:    [[T2:%.*]] = insertelement <2 x float> [[T1]], float [[SCALE]], i32 1
 529 ; CHECK-NEXT:    [[T3:%.*]] = fmul <2 x float> [[OP]], [[T2]]
 530 ; CHECK-NEXT:    [[T4:%.*]] = extractelement <2 x float> [[T3]], i32 0
 531 ; CHECK-NEXT:    [[RESULT0:%.*]] = insertelement <2 x float> undef, float [[T4]], i32 0
 532 ; CHECK-NEXT:    [[T5:%.*]] = extractelement <2 x float> [[T3]], i32 1
 533 ; CHECK-NEXT:    [[RESULT1:%.*]] = insertelement <2 x float> [[RESULT0]], float [[T5]], i32 1
 534 ; CHECK-NEXT:    store <2 x float> [[RESULT1]], ptr [[RESULTPTR:%.*]], align 8
 535 ; CHECK-NEXT:    ret void
 536 ;
 537   %scaleptr = tail call nonnull align 16 dereferenceable(64) ptr @getscaleptr()
 538   %op = load <2 x float>, ptr %opptr, align 4
 539   %scale = load float, ptr %scaleptr, align 16
 540   %t1 = insertelement <2 x float> undef, float %scale, i32 0
 541   %t2 = insertelement <2 x float> %t1, float %scale, i32 1
 542   %t3 = fmul <2 x float> %op, %t2
 543   %t4 = extractelement <2 x float> %t3, i32 0
 544   %result0 = insertelement <2 x float> undef, float %t4, i32 0
 545   %t5 = extractelement <2 x float> %t3, i32 1
 546   %result1 = insertelement <2 x float> %result0, float %t5, i32 1
 547   store <2 x float> %result1, ptr %resultptr, align 8
 548   ret void
 549 }
 550
 551 define <4 x float> @load_v2f32_extract_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 552 ; CHECK-LABEL: @load_v2f32_extract_insert_v4f32(
 553 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 554 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 555 ; CHECK-NEXT:    ret <4 x float> [[R]]
 556 ;
 557   %l = load <2 x float>, ptr %p, align 4
 558   %s = extractelement <2 x float> %l, i32 0
 559   %r = insertelement <4 x float> undef, float %s, i32 0
 560   ret <4 x float> %r
 561 }
 562
 563 define <4 x float> @load_v8f32_extract_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 564 ; CHECK-LABEL: @load_v8f32_extract_insert_v4f32(
 565 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 566 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 567 ; CHECK-NEXT:    ret <4 x float> [[R]]
 568 ;
 569   %l = load <8 x float>, ptr %p, align 4
 570   %s = extractelement <8 x float> %l, i32 0
 571   %r = insertelement <4 x float> undef, float %s, i32 0
 572   ret <4 x float> %r
 573 }
 574
 575 define <8 x i32> @load_v1i32_extract_insert_v8i32_extra_use(ptr align 16 dereferenceable(16) %p, ptr %store_ptr) nofree nosync {
 576 ; CHECK-LABEL: @load_v1i32_extract_insert_v8i32_extra_use(
 577 ; CHECK-NEXT:    [[L:%.*]] = load <1 x i32>, ptr [[P:%.*]], align 4
 578 ; CHECK-NEXT:    store <1 x i32> [[L]], ptr [[STORE_PTR:%.*]], align 4
 579 ; CHECK-NEXT:    [[S:%.*]] = extractelement <1 x i32> [[L]], i32 0
 580 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i32> undef, i32 [[S]], i32 0
 581 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 582 ;
 583   %l = load <1 x i32>, ptr %p, align 4
 584   store <1 x i32> %l, ptr %store_ptr
 585   %s = extractelement <1 x i32> %l, i32 0
 586   %r = insertelement <8 x i32> undef, i32 %s, i32 0
 587   ret <8 x i32> %r
 588 }
 589
 590 ; Can't safely load the offset vector, but can load+shuffle if it is profitable.
 591
 592 define <8 x i16> @gep1_load_v2i16_extract_insert_v8i16(ptr align 1 dereferenceable(16) %p) nofree nosync {
 593 ; SSE2-LABEL: @gep1_load_v2i16_extract_insert_v8i16(
 594 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <2 x i16>, ptr [[P:%.*]], i64 1
 595 ; SSE2-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <2 x i16>, ptr [[GEP]], i32 0, i32 0
 596 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[TMP1]], align 8
 597 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> undef, i16 [[S]], i64 0
 598 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 599 ;
 600 ; AVX2-LABEL: @gep1_load_v2i16_extract_insert_v8i16(
 601 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 4
 602 ; AVX2-NEXT:    [[R:%.*]] = shufflevector <8 x i16> [[TMP1]], <8 x i16> poison, <8 x i32> <i32 2, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
 603 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 604 ;
 605   %gep = getelementptr inbounds <2 x i16>, ptr %p, i64 1
 606   %l = load <2 x i16>, ptr %gep, align 8
 607   %s = extractelement <2 x i16> %l, i32 0
 608   %r = insertelement <8 x i16> undef, i16 %s, i64 0
 609   ret <8 x i16> %r
 610 }
 611
 612 ; PR30986 - split vector loads for scalarized operations
 613 define <2 x i64> @PR30986(ptr %0) {
 614 ; CHECK-LABEL: @PR30986(
 615 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds <2 x i64>, ptr [[TMP0:%.*]], i32 0, i32 0
 616 ; CHECK-NEXT:    [[TMP3:%.*]] = load i64, ptr [[TMP2]], align 16
 617 ; CHECK-NEXT:    [[TMP4:%.*]] = tail call i64 @llvm.ctpop.i64(i64 [[TMP3]])
 618 ; CHECK-NEXT:    [[TMP5:%.*]] = insertelement <2 x i64> undef, i64 [[TMP4]], i32 0
 619 ; CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds <2 x i64>, ptr [[TMP0]], i32 0, i32 1
 620 ; CHECK-NEXT:    [[TMP7:%.*]] = load i64, ptr [[TMP6]], align 8
 621 ; CHECK-NEXT:    [[TMP8:%.*]] = tail call i64 @llvm.ctpop.i64(i64 [[TMP7]])
 622 ; CHECK-NEXT:    [[TMP9:%.*]] = insertelement <2 x i64> [[TMP5]], i64 [[TMP8]], i32 1
 623 ; CHECK-NEXT:    ret <2 x i64> [[TMP9]]
 624 ;
 625   %2 = load <2 x i64>, ptr %0, align 16
 626   %3 = extractelement <2 x i64> %2, i32 0
 627   %4 = tail call i64 @llvm.ctpop.i64(i64 %3)
 628   %5 = insertelement <2 x i64> undef, i64 %4, i32 0
 629   %6 = extractelement <2 x i64> %2, i32 1
 630   %7 = tail call i64 @llvm.ctpop.i64(i64 %6)
 631   %8 = insertelement <2 x i64> %5, i64 %7, i32 1
 632   ret <2 x i64> %8
 633 }
 634 declare i64 @llvm.ctpop.i64(i64)