llvm/test/Transforms/VectorCombine/X86/load-inseltpoison.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> poison, 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> poison, 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> poison, 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> poison, 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> poison, 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> poison, float %s, i64 0
 230   ret <4 x float> %r
 231 }
 232
 233 ; Should work with addrspace even when peeking past unsafe loads through geps
 234
 235 define <4 x i32> @unsafe_load_i32_insert_v4i32_addrspace(ptr align 16 dereferenceable(16) %v3) {
 236 ; CHECK-LABEL: @unsafe_load_i32_insert_v4i32_addrspace(
 237 ; CHECK-NEXT:    [[TMP1:%.*]] = addrspacecast ptr [[V3:%.*]] to ptr addrspace(42)
 238 ; CHECK-NEXT:    [[TMP2:%.*]] = load <4 x i32>, ptr addrspace(42) [[TMP1]], align 16
 239 ; CHECK-NEXT:    [[INSELT:%.*]] = shufflevector <4 x i32> [[TMP2]], <4 x i32> poison, <4 x i32> <i32 2, i32 poison, i32 poison, i32 poison>
 240 ; CHECK-NEXT:    ret <4 x i32> [[INSELT]]
 241 ;
 242   %t0 = getelementptr inbounds i32, ptr %v3, i32 1
 243   %t1 = addrspacecast ptr %t0 to ptr addrspace(42)
 244   %t2 = getelementptr inbounds i32, ptr addrspace(42) %t1, i64 1
 245   %val = load i32, ptr addrspace(42) %t2, align 4
 246   %inselt = insertelement <4 x i32> poison, i32 %val, i32 0
 247   ret <4 x i32> %inselt
 248 }
 249
 250 ; If there are enough dereferenceable bytes, we can offset the vector load.
 251
 252 define <8 x i16> @gep01_load_i16_insert_v8i16(ptr align 16 dereferenceable(18) %p) nofree nosync {
 253 ; CHECK-LABEL: @gep01_load_i16_insert_v8i16(
 254 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 255 ; CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[GEP]], align 2
 256 ; 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>
 257 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 258 ;
 259   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 260   %s = load i16, ptr %gep, align 2
 261   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 262   ret <8 x i16> %r
 263 }
 264
 265 ; Can't safely load the offset vector, but can load+shuffle if it is profitable.
 266
 267 define <8 x i16> @gep01_load_i16_insert_v8i16_deref(ptr align 16 dereferenceable(17) %p) nofree nosync {
 268 ; SSE2-LABEL: @gep01_load_i16_insert_v8i16_deref(
 269 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 270 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 2
 271 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 272 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 273 ;
 274 ; AVX2-LABEL: @gep01_load_i16_insert_v8i16_deref(
 275 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 16
 276 ; 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>
 277 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 278 ;
 279   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 280   %s = load i16, ptr %gep, align 2
 281   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 282   ret <8 x i16> %r
 283 }
 284
 285 ; Verify that alignment of the new load is not over-specified.
 286
 287 define <8 x i16> @gep01_load_i16_insert_v8i16_deref_minalign(ptr align 2 dereferenceable(16) %p) nofree nosync {
 288 ; SSE2-LABEL: @gep01_load_i16_insert_v8i16_deref_minalign(
 289 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 0, i64 1
 290 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 8
 291 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 292 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 293 ;
 294 ; AVX2-LABEL: @gep01_load_i16_insert_v8i16_deref_minalign(
 295 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 2
 296 ; 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>
 297 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 298 ;
 299   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 0, i64 1
 300   %s = load i16, ptr %gep, align 8
 301   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 302   ret <8 x i16> %r
 303 }
 304
 305 ; Negative test - if we are shuffling a load from the base pointer, the address offset
 306 ; must be a multiple of element size.
 307 ; TODO: Could bitcast around this limitation.
 308
 309 define <4 x i32> @gep01_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(16) %p) nofree nosync {
 310 ; CHECK-LABEL: @gep01_bitcast_load_i32_insert_v4i32(
 311 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <16 x i8>, ptr [[P:%.*]], i64 0, i64 1
 312 ; CHECK-NEXT:    [[S:%.*]] = load i32, ptr [[GEP]], align 1
 313 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x i32> poison, i32 [[S]], i64 0
 314 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 315 ;
 316   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 1
 317   %s = load i32, ptr %gep, align 1
 318   %r = insertelement <4 x i32> poison, i32 %s, i64 0
 319   ret <4 x i32> %r
 320 }
 321
 322 define <4 x i32> @gep012_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(20) %p) nofree nosync {
 323 ; CHECK-LABEL: @gep012_bitcast_load_i32_insert_v4i32(
 324 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 1
 325 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x i32> [[TMP1]], <4 x i32> poison, <4 x i32> <i32 3, i32 poison, i32 poison, i32 poison>
 326 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 327 ;
 328   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 12
 329   %s = load i32, ptr %gep, align 1
 330   %r = insertelement <4 x i32> poison, i32 %s, i64 0
 331   ret <4 x i32> %r
 332 }
 333
 334 ; Negative test - if we are shuffling a load from the base pointer, the address offset
 335 ; must be a multiple of element size and the offset must be low enough to fit in the vector
 336 ; (bitcasting would not help this case).
 337
 338 define <4 x i32> @gep013_bitcast_load_i32_insert_v4i32(ptr align 1 dereferenceable(20) %p) nofree nosync {
 339 ; CHECK-LABEL: @gep013_bitcast_load_i32_insert_v4i32(
 340 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <16 x i8>, ptr [[P:%.*]], i64 0, i64 13
 341 ; CHECK-NEXT:    [[S:%.*]] = load i32, ptr [[GEP]], align 1
 342 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x i32> poison, i32 [[S]], i64 0
 343 ; CHECK-NEXT:    ret <4 x i32> [[R]]
 344 ;
 345   %gep = getelementptr inbounds <16 x i8>, ptr %p, i64 0, i64 13
 346   %s = load i32, ptr %gep, align 1
 347   %r = insertelement <4 x i32> poison, i32 %s, i64 0
 348   ret <4 x i32> %r
 349 }
 350
 351 ; If there are enough dereferenceable bytes, we can offset the vector load.
 352
 353 define <8 x i16> @gep10_load_i16_insert_v8i16(ptr align 16 dereferenceable(32) %p) nofree nosync {
 354 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16(
 355 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 356 ; CHECK-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[GEP]], align 16
 357 ; 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>
 358 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 359 ;
 360   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 361   %s = load i16, ptr %gep, align 16
 362   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 363   ret <8 x i16> %r
 364 }
 365
 366 ; Negative test - disable under asan because widened load can cause spurious
 367 ; use-after-poison issues when __asan_poison_memory_region is used.
 368
 369 define <8 x i16> @gep10_load_i16_insert_v8i16_asan(ptr align 16 dereferenceable(32) %p) sanitize_address {
 370 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_asan(
 371 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 372 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 373 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 374 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 375 ;
 376   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 377   %s = load i16, ptr %gep, align 16
 378   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 379   ret <8 x i16> %r
 380 }
 381
 382 ; hwasan and memtag should be similarly suppressed.
 383
 384 define <8 x i16> @gep10_load_i16_insert_v8i16_hwasan(ptr align 16 dereferenceable(32) %p) sanitize_hwaddress {
 385 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_hwasan(
 386 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 387 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 388 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 389 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 390 ;
 391   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 392   %s = load i16, ptr %gep, align 16
 393   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 394   ret <8 x i16> %r
 395 }
 396
 397 define <8 x i16> @gep10_load_i16_insert_v8i16_memtag(ptr align 16 dereferenceable(32) %p) sanitize_memtag {
 398 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_memtag(
 399 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 400 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 401 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 402 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 403 ;
 404   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 405   %s = load i16, ptr %gep, align 16
 406   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 407   ret <8 x i16> %r
 408 }
 409
 410 ; Negative test - disable under tsan because widened load may overlap bytes
 411 ; being concurrently modified. tsan does not know that some bytes are undef.
 412
 413 define <8 x i16> @gep10_load_i16_insert_v8i16_tsan(ptr align 16 dereferenceable(32) %p) sanitize_thread {
 414 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_tsan(
 415 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 416 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 417 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 418 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 419 ;
 420   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 421   %s = load i16, ptr %gep, align 16
 422   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 423   ret <8 x i16> %r
 424 }
 425
 426 ; Negative test - can't safely load the offset vector, but could load+shuffle.
 427
 428 define <8 x i16> @gep10_load_i16_insert_v8i16_deref(ptr align 16 dereferenceable(31) %p) nofree nosync {
 429 ; CHECK-LABEL: @gep10_load_i16_insert_v8i16_deref(
 430 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds <8 x i16>, ptr [[P:%.*]], i64 1, i64 0
 431 ; CHECK-NEXT:    [[S:%.*]] = load i16, ptr [[GEP]], align 16
 432 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 433 ; CHECK-NEXT:    ret <8 x i16> [[R]]
 434 ;
 435   %gep = getelementptr inbounds <8 x i16>, ptr %p, i64 1, i64 0
 436   %s = load i16, ptr %gep, align 16
 437   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 438   ret <8 x i16> %r
 439 }
 440
 441 ; Negative test - do not alter volatile.
 442
 443 define <4 x float> @load_f32_insert_v4f32_volatile(ptr align 16 dereferenceable(16) %p) nofree nosync {
 444 ; CHECK-LABEL: @load_f32_insert_v4f32_volatile(
 445 ; CHECK-NEXT:    [[S:%.*]] = load volatile float, ptr [[P:%.*]], align 4
 446 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> poison, float [[S]], i32 0
 447 ; CHECK-NEXT:    ret <4 x float> [[R]]
 448 ;
 449   %s = load volatile float, ptr %p, align 4
 450   %r = insertelement <4 x float> poison, float %s, i32 0
 451   ret <4 x float> %r
 452 }
 453
 454 ; Pointer is not as aligned as load, but that's ok.
 455 ; The new load uses the larger alignment value.
 456
 457 define <4 x float> @load_f32_insert_v4f32_align(ptr align 1 dereferenceable(16) %p) nofree nosync {
 458 ; CHECK-LABEL: @load_f32_insert_v4f32_align(
 459 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 4
 460 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 461 ; CHECK-NEXT:    ret <4 x float> [[R]]
 462 ;
 463   %s = load float, ptr %p, align 4
 464   %r = insertelement <4 x float> poison, float %s, i32 0
 465   ret <4 x float> %r
 466 }
 467
 468 ; Negative test - not enough bytes.
 469
 470 define <4 x float> @load_f32_insert_v4f32_deref(ptr align 4 dereferenceable(15) %p) nofree nosync {
 471 ; CHECK-LABEL: @load_f32_insert_v4f32_deref(
 472 ; CHECK-NEXT:    [[S:%.*]] = load float, ptr [[P:%.*]], align 4
 473 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> poison, float [[S]], i32 0
 474 ; CHECK-NEXT:    ret <4 x float> [[R]]
 475 ;
 476   %s = load float, ptr %p, align 4
 477   %r = insertelement <4 x float> poison, float %s, i32 0
 478   ret <4 x float> %r
 479 }
 480
 481 define <8 x i32> @load_i32_insert_v8i32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 482 ; CHECK-LABEL: @load_i32_insert_v8i32(
 483 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 16
 484 ; 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>
 485 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 486 ;
 487   %s = load i32, ptr %p, align 4
 488   %r = insertelement <8 x i32> poison, i32 %s, i32 0
 489   ret <8 x i32> %r
 490 }
 491
 492 define <8 x i32> @casted_load_i32_insert_v8i32(ptr align 4 dereferenceable(16) %p) nofree nosync {
 493 ; CHECK-LABEL: @casted_load_i32_insert_v8i32(
 494 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x i32>, ptr [[P:%.*]], align 4
 495 ; 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>
 496 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 497 ;
 498   %s = load i32, ptr %p, align 4
 499   %r = insertelement <8 x i32> poison, i32 %s, i32 0
 500   ret <8 x i32> %r
 501 }
 502
 503 define <16 x float> @load_f32_insert_v16f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 504 ; CHECK-LABEL: @load_f32_insert_v16f32(
 505 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 506 ; 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>
 507 ; CHECK-NEXT:    ret <16 x float> [[R]]
 508 ;
 509   %s = load float, ptr %p, align 4
 510   %r = insertelement <16 x float> poison, float %s, i32 0
 511   ret <16 x float> %r
 512 }
 513
 514 define <2 x float> @load_f32_insert_v2f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 515 ; CHECK-LABEL: @load_f32_insert_v2f32(
 516 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 517 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <2 x i32> <i32 0, i32 poison>
 518 ; CHECK-NEXT:    ret <2 x float> [[R]]
 519 ;
 520   %s = load float, ptr %p, align 4
 521   %r = insertelement <2 x float> poison, float %s, i32 0
 522   ret <2 x float> %r
 523 }
 524
 525 ; Negative test - suppress load widening for asan/hwasan/memtag/tsan.
 526
 527 define <2 x float> @load_f32_insert_v2f32_asan(ptr align 16 dereferenceable(16) %p) sanitize_address {
 528 ; CHECK-LABEL: @load_f32_insert_v2f32_asan(
 529 ; CHECK-NEXT:    [[S:%.*]] = load float, ptr [[P:%.*]], align 4
 530 ; CHECK-NEXT:    [[R:%.*]] = insertelement <2 x float> poison, float [[S]], i32 0
 531 ; CHECK-NEXT:    ret <2 x float> [[R]]
 532 ;
 533   %s = load float, ptr %p, align 4
 534   %r = insertelement <2 x float> poison, float %s, i32 0
 535   ret <2 x float> %r
 536 }
 537
 538 declare ptr @getscaleptr()
 539 define void @PR47558_multiple_use_load(ptr nocapture nonnull %resultptr, ptr nocapture nonnull readonly %opptr) nofree nosync {
 540 ; CHECK-LABEL: @PR47558_multiple_use_load(
 541 ; CHECK-NEXT:    [[SCALEPTR:%.*]] = tail call nonnull align 16 dereferenceable(64) ptr @getscaleptr()
 542 ; CHECK-NEXT:    [[OP:%.*]] = load <2 x float>, ptr [[OPPTR:%.*]], align 4
 543 ; CHECK-NEXT:    [[SCALE:%.*]] = load float, ptr [[SCALEPTR]], align 16
 544 ; CHECK-NEXT:    [[T1:%.*]] = insertelement <2 x float> poison, float [[SCALE]], i32 0
 545 ; CHECK-NEXT:    [[T2:%.*]] = insertelement <2 x float> [[T1]], float [[SCALE]], i32 1
 546 ; CHECK-NEXT:    [[T3:%.*]] = fmul <2 x float> [[OP]], [[T2]]
 547 ; CHECK-NEXT:    [[T4:%.*]] = extractelement <2 x float> [[T3]], i32 0
 548 ; CHECK-NEXT:    [[RESULT0:%.*]] = insertelement <2 x float> poison, float [[T4]], i32 0
 549 ; CHECK-NEXT:    [[T5:%.*]] = extractelement <2 x float> [[T3]], i32 1
 550 ; CHECK-NEXT:    [[RESULT1:%.*]] = insertelement <2 x float> [[RESULT0]], float [[T5]], i32 1
 551 ; CHECK-NEXT:    store <2 x float> [[RESULT1]], ptr [[RESULTPTR:%.*]], align 8
 552 ; CHECK-NEXT:    ret void
 553 ;
 554   %scaleptr = tail call nonnull align 16 dereferenceable(64) ptr @getscaleptr()
 555   %op = load <2 x float>, ptr %opptr, align 4
 556   %scale = load float, ptr %scaleptr, align 16
 557   %t1 = insertelement <2 x float> poison, float %scale, i32 0
 558   %t2 = insertelement <2 x float> %t1, float %scale, i32 1
 559   %t3 = fmul <2 x float> %op, %t2
 560   %t4 = extractelement <2 x float> %t3, i32 0
 561   %result0 = insertelement <2 x float> poison, float %t4, i32 0
 562   %t5 = extractelement <2 x float> %t3, i32 1
 563   %result1 = insertelement <2 x float> %result0, float %t5, i32 1
 564   store <2 x float> %result1, ptr %resultptr, align 8
 565   ret void
 566 }
 567
 568 define <4 x float> @load_v2f32_extract_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 569 ; CHECK-LABEL: @load_v2f32_extract_insert_v4f32(
 570 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 571 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 572 ; CHECK-NEXT:    ret <4 x float> [[R]]
 573 ;
 574   %l = load <2 x float>, ptr %p, align 4
 575   %s = extractelement <2 x float> %l, i32 0
 576   %r = insertelement <4 x float> poison, float %s, i32 0
 577   ret <4 x float> %r
 578 }
 579
 580 define <4 x float> @load_v8f32_extract_insert_v4f32(ptr align 16 dereferenceable(16) %p) nofree nosync {
 581 ; CHECK-LABEL: @load_v8f32_extract_insert_v4f32(
 582 ; CHECK-NEXT:    [[TMP1:%.*]] = load <4 x float>, ptr [[P:%.*]], align 16
 583 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> poison, <4 x i32> <i32 0, i32 poison, i32 poison, i32 poison>
 584 ; CHECK-NEXT:    ret <4 x float> [[R]]
 585 ;
 586   %l = load <8 x float>, ptr %p, align 4
 587   %s = extractelement <8 x float> %l, i32 0
 588   %r = insertelement <4 x float> poison, float %s, i32 0
 589   ret <4 x float> %r
 590 }
 591
 592 define <8 x i32> @load_v1i32_extract_insert_v8i32_extra_use(ptr align 16 dereferenceable(16) %p, ptr %store_ptr) nofree nosync {
 593 ; CHECK-LABEL: @load_v1i32_extract_insert_v8i32_extra_use(
 594 ; CHECK-NEXT:    [[L:%.*]] = load <1 x i32>, ptr [[P:%.*]], align 4
 595 ; CHECK-NEXT:    store <1 x i32> [[L]], ptr [[STORE_PTR:%.*]], align 4
 596 ; CHECK-NEXT:    [[S:%.*]] = extractelement <1 x i32> [[L]], i32 0
 597 ; CHECK-NEXT:    [[R:%.*]] = insertelement <8 x i32> poison, i32 [[S]], i32 0
 598 ; CHECK-NEXT:    ret <8 x i32> [[R]]
 599 ;
 600   %l = load <1 x i32>, ptr %p, align 4
 601   store <1 x i32> %l, ptr %store_ptr
 602   %s = extractelement <1 x i32> %l, i32 0
 603   %r = insertelement <8 x i32> poison, i32 %s, i32 0
 604   ret <8 x i32> %r
 605 }
 606
 607 ; Can't safely load the offset vector, but can load+shuffle if it is profitable.
 608
 609 define <8 x i16> @gep1_load_v2i16_extract_insert_v8i16(ptr align 1 dereferenceable(16) %p) nofree nosync {
 610 ; SSE2-LABEL: @gep1_load_v2i16_extract_insert_v8i16(
 611 ; SSE2-NEXT:    [[GEP:%.*]] = getelementptr inbounds <2 x i16>, ptr [[P:%.*]], i64 1
 612 ; SSE2-NEXT:    [[TMP1:%.*]] = getelementptr inbounds <2 x i16>, ptr [[GEP]], i32 0, i32 0
 613 ; SSE2-NEXT:    [[S:%.*]] = load i16, ptr [[TMP1]], align 8
 614 ; SSE2-NEXT:    [[R:%.*]] = insertelement <8 x i16> poison, i16 [[S]], i64 0
 615 ; SSE2-NEXT:    ret <8 x i16> [[R]]
 616 ;
 617 ; AVX2-LABEL: @gep1_load_v2i16_extract_insert_v8i16(
 618 ; AVX2-NEXT:    [[TMP1:%.*]] = load <8 x i16>, ptr [[P:%.*]], align 4
 619 ; 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>
 620 ; AVX2-NEXT:    ret <8 x i16> [[R]]
 621 ;
 622   %gep = getelementptr inbounds <2 x i16>, ptr %p, i64 1
 623   %l = load <2 x i16>, ptr %gep, align 8
 624   %s = extractelement <2 x i16> %l, i32 0
 625   %r = insertelement <8 x i16> poison, i16 %s, i64 0
 626   ret <8 x i16> %r
 627 }
 628
 629 ; PR30986 - split vector loads for scalarized operations
 630 define <2 x i64> @PR30986(ptr %0) {
 631 ; CHECK-LABEL: @PR30986(
 632 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds <2 x i64>, ptr [[TMP0:%.*]], i32 0, i32 0
 633 ; CHECK-NEXT:    [[TMP3:%.*]] = load i64, ptr [[TMP2]], align 16
 634 ; CHECK-NEXT:    [[TMP4:%.*]] = tail call i64 @llvm.ctpop.i64(i64 [[TMP3]])
 635 ; CHECK-NEXT:    [[TMP5:%.*]] = insertelement <2 x i64> poison, i64 [[TMP4]], i32 0
 636 ; CHECK-NEXT:    [[TMP6:%.*]] = getelementptr inbounds <2 x i64>, ptr [[TMP0]], i32 0, i32 1
 637 ; CHECK-NEXT:    [[TMP7:%.*]] = load i64, ptr [[TMP6]], align 8
 638 ; CHECK-NEXT:    [[TMP8:%.*]] = tail call i64 @llvm.ctpop.i64(i64 [[TMP7]])
 639 ; CHECK-NEXT:    [[TMP9:%.*]] = insertelement <2 x i64> [[TMP5]], i64 [[TMP8]], i32 1
 640 ; CHECK-NEXT:    ret <2 x i64> [[TMP9]]
 641 ;
 642   %2 = load <2 x i64>, ptr %0, align 16
 643   %3 = extractelement <2 x i64> %2, i32 0
 644   %4 = tail call i64 @llvm.ctpop.i64(i64 %3)
 645   %5 = insertelement <2 x i64> poison, i64 %4, i32 0
 646   %6 = extractelement <2 x i64> %2, i32 1
 647   %7 = tail call i64 @llvm.ctpop.i64(i64 %6)
 648   %8 = insertelement <2 x i64> %5, i64 %7, i32 1
 649   ret <2 x i64> %8
 650 }
 651 declare i64 @llvm.ctpop.i64(i64)