llvm/test/Transforms/LoopVectorize/widen-call-attrs.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals none --version 6
; RUN: opt -passes=loop-vectorize -force-vector-width=2 -force-vector-interleave=1 -S %s | FileCheck %s

declare i32 @scalar_fn_uniform_ptr(ptr) #0
declare <2 x i32> @vec_fn_uniform_ptr(ptr) #0

declare i32 @scalar_fn_vec_ptr(ptr) #1
declare <2 x i32> @vec_fn_vec_ptr(<2 x ptr>) #1

declare i32 @scalar_fn_int(i32) #2
declare <2 x i32> @vec_fn_int(<2 x i32>) #2

declare float @scalar_fn_fp(float) #3
declare <2 x float> @vec_fn_fp(<2 x float>) #3

declare i32 @scalar_byval_fn(ptr byval(i32)) #4
declare <2 x i32> @vec_byval_fn(ptr) #4

declare i32 @scalar_fn_int_variant_attrs(i32) #5
declare <2 x i32> @vec_fn_int_variant_attrs(<2 x i32> range(i32 0, 50)) #5

declare i32 @scalar_fn_uniform_ptr_variant_attrs(ptr) #6
declare <2 x i32> @vec_fn_uniform_ptr_variant_attrs(ptr align 32) #6

declare float @scalar_fn_fp_variant_attrs(float) #7
declare <2 x float> @vec_fn_fp_variant_attrs(<2 x float> nofpclass(nan inf)) #7

define void @combined_stripped_uniform_ptr(ptr noalias %p, ptr noalias %out) {
; CHECK-LABEL: define void @combined_stripped_uniform_ptr(
; CHECK-SAME: ptr noalias [[P:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    [[TMP0:%.*]] = call <2 x i32> @vec_fn_uniform_ptr(ptr [[P]])
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP0]], ptr [[TMP1]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP0:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %r = call i32 @scalar_fn_uniform_ptr(ptr noalias writable captures(none) dead_on_return dead_on_unwind noundef dereferenceable(16) dereferenceable_or_null(16) %p)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; noalias on a vector-of-pointers parameter is dropped (per-iteration
; disjointness does not imply lane-disjointness within a single call).
define void @noalias_vec_ptr_stripped(ptr noalias %dst, ptr noalias %out) {
; CHECK-LABEL: define void @noalias_vec_ptr_stripped(
; CHECK-SAME: ptr noalias [[DST:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr ptr, ptr [[DST]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x ptr>, ptr [[TMP0]], align 8
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_vec_ptr(<2 x ptr> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP3:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %p.gep = getelementptr ptr, ptr %dst, i64 %iv
  %x = load ptr, ptr %p.gep
  %r = call i32 @scalar_fn_vec_ptr(ptr noalias %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; noundef on a parameter and on the return value is UB-implying and must
; be stripped from the widened call: masked-off lanes can be poison.
define void @noundef_arg_and_ret_stripped(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @noundef_arg_and_ret_stripped(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_int(<2 x i32> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP4:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr i32, ptr %src, i64 %iv
  %x = load i32, ptr %s.gep
  %r = call noundef i32 @scalar_fn_int(i32 noundef %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; range(...) is poison-on-violation. It should propagate.
define void @range_arg_propagated(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @range_arg_propagated(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_int(<2 x i32> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP5:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr i32, ptr %src, i64 %iv
  %x = load i32, ptr %s.gep
  %r = call i32 @scalar_fn_int(i32 range(i32 0, 100) %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; nofpclass is poison-on-violation. It should propagate.
define void @nofpclass_propagated(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @nofpclass_propagated(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr float, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x float>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @vec_fn_fp(<2 x float> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr float, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x float> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP6:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr float, ptr %src, i64 %iv
  %x = load float, ptr %s.gep
  %r = call nofpclass(nan) float @scalar_fn_fp(float nofpclass(nan) %x)
  %o.gep = getelementptr float, ptr %out, i64 %iv
  store float %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; align on a uniform pointer arg should propagate.
define void @align_uniform_ptr_propagated(ptr noalias %p, ptr noalias %out) {
; CHECK-LABEL: define void @align_uniform_ptr_propagated(
; CHECK-SAME: ptr noalias [[P:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    [[TMP0:%.*]] = call <2 x i32> @vec_fn_uniform_ptr(ptr [[P]])
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP0]], ptr [[TMP1]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP7:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %r = call i32 @scalar_fn_uniform_ptr(ptr align 16 %p)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; nonnull is poison-on-violation. It should propagate.
define void @nonnull_uniform_ptr_propagated(ptr noalias %p, ptr noalias %out) {
; CHECK-LABEL: define void @nonnull_uniform_ptr_propagated(
; CHECK-SAME: ptr noalias [[P:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    [[TMP0:%.*]] = call <2 x i32> @vec_fn_uniform_ptr(ptr [[P]])
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP0]], ptr [[TMP1]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP8:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %r = call i32 @scalar_fn_uniform_ptr(ptr nonnull %p)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; byval(T) is an ABI parameter attribute and cannot be preserved for different
; types.
define void @byval_stripped(ptr noalias %p, ptr noalias %out) {
; CHECK-LABEL: define void @byval_stripped(
; CHECK-SAME: ptr noalias [[P:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    [[TMP0:%.*]] = call <2 x i32> @vec_byval_fn(ptr [[P]])
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP0]], ptr [[TMP1]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP9:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %r = call i32 @scalar_byval_fn(ptr byval(i32) %p)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}


; The variant declaration carries range(i32 0, 50) on its parameter; the
; scalar call site's range(i32 0, 100). Should keep the stricter range.
define void @range_arg_variant_decl_wins(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @range_arg_variant_decl_wins(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_int_variant_attrs(<2 x i32> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP10:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr i32, ptr %src, i64 %iv
  %x = load i32, ptr %s.gep
  %r = call i32 @scalar_fn_int_variant_attrs(i32 range(i32 0, 100) %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; The variant declaration carries align 32 on its parameter; the scalar
; call site's align 16. Should keep the stricter alignment.
; should keep the variant's align 32.
define void @align_uniform_ptr_variant_decl_wins(ptr noalias %p, ptr noalias %out) {
; CHECK-LABEL: define void @align_uniform_ptr_variant_decl_wins(
; CHECK-SAME: ptr noalias [[P:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    [[TMP0:%.*]] = call <2 x i32> @vec_fn_uniform_ptr_variant_attrs(ptr [[P]])
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP0]], ptr [[TMP1]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP2:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP2]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP11:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %r = call i32 @scalar_fn_uniform_ptr_variant_attrs(ptr align 16 %p)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; The variant declaration carries nofpclass(nan inf) on its parameter; the
; scalar call site's weaker nofpclass(nan). Should keep the stricter mask.
define void @nofpclass_arg_variant_decl_wins(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @nofpclass_arg_variant_decl_wins(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr float, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x float>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @vec_fn_fp_variant_attrs(<2 x float> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr float, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x float> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP12:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr float, ptr %src, i64 %iv
  %x = load float, ptr %s.gep
  %r = call float @scalar_fn_fp_variant_attrs(float nofpclass(nan) %x)
  %o.gep = getelementptr float, ptr %out, i64 %iv
  store float %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; range on the return value is poison-on-violation. Should be propagated.
define void @range_ret_propagated(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @range_ret_propagated(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_int(<2 x i32> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP13:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr i32, ptr %src, i64 %iv
  %x = load i32, ptr %s.gep
  %r = call range(i32 0, 100) i32 @scalar_fn_int(i32 %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; align N can be propagated to widened pointers.
define void @align_vec_ptr_propagated(ptr noalias %dst, ptr noalias %out) {
; CHECK-LABEL: define void @align_vec_ptr_propagated(
; CHECK-SAME: ptr noalias [[DST:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr ptr, ptr [[DST]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x ptr>, ptr [[TMP0]], align 8
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_vec_ptr(<2 x ptr> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP14:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %p.gep = getelementptr ptr, ptr %dst, i64 %iv
  %x = load ptr, ptr %p.gep
  %r = call i32 @scalar_fn_vec_ptr(ptr align 16 %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; nonnull cannot be propagated to widened pointer vectors currently.
define void @nonnull_vec_ptr_dropped(ptr noalias %dst, ptr noalias %out) {
; CHECK-LABEL: define void @nonnull_vec_ptr_dropped(
; CHECK-SAME: ptr noalias [[DST:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr ptr, ptr [[DST]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x ptr>, ptr [[TMP0]], align 8
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_vec_ptr(<2 x ptr> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP15:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %p.gep = getelementptr ptr, ptr %dst, i64 %iv
  %x = load ptr, ptr %p.gep
  %r = call i32 @scalar_fn_vec_ptr(ptr nonnull %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

; signext/zeroext are ABI parameter attributes, Should not be propagated.
define void @signext_zeroext_stripped(ptr noalias %src, ptr noalias %out) {
; CHECK-LABEL: define void @signext_zeroext_stripped(
; CHECK-SAME: ptr noalias [[SRC:%.*]], ptr noalias [[OUT:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    br label %[[VECTOR_PH:.*]]
; CHECK:       [[VECTOR_PH]]:
; CHECK-NEXT:    br label %[[VECTOR_BODY:.*]]
; CHECK:       [[VECTOR_BODY]]:
; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %[[VECTOR_PH]] ], [ [[INDEX_NEXT:%.*]], %[[VECTOR_BODY]] ]
; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, ptr [[SRC]], i64 [[INDEX]]
; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x i32> @vec_fn_int(<2 x i32> [[WIDE_LOAD]])
; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr i32, ptr [[OUT]], i64 [[INDEX]]
; CHECK-NEXT:    store <2 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT:    [[INDEX_NEXT]] = add nuw i64 [[INDEX]], 2
; CHECK-NEXT:    [[TMP3:%.*]] = icmp eq i64 [[INDEX_NEXT]], 1024
; CHECK-NEXT:    br i1 [[TMP3]], label %[[MIDDLE_BLOCK:.*]], label %[[VECTOR_BODY]], !llvm.loop [[LOOP16:![0-9]+]]
; CHECK:       [[MIDDLE_BLOCK]]:
; CHECK-NEXT:    br label %[[EXIT:.*]]
; CHECK:       [[EXIT]]:
; CHECK-NEXT:    ret void
;
entry:
  br label %loop

loop:
  %iv = phi i64 [0, %entry], [%iv.next, %loop]
  %s.gep = getelementptr i32, ptr %src, i64 %iv
  %x = load i32, ptr %s.gep
  %r = call signext i32 @scalar_fn_int(i32 zeroext %x)
  %o.gep = getelementptr i32, ptr %out, i64 %iv
  store i32 %r, ptr %o.gep
  %iv.next = add i64 %iv, 1
  %done = icmp eq i64 %iv.next, 1024
  br i1 %done, label %exit, label %loop

exit:
  ret void
}

attributes #0 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2u_scalar_fn_uniform_ptr(vec_fn_uniform_ptr)" }
attributes #1 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2v_scalar_fn_vec_ptr(vec_fn_vec_ptr)" }
attributes #2 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2v_scalar_fn_int(vec_fn_int)" }
attributes #3 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2v_scalar_fn_fp(vec_fn_fp)" }
attributes #4 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2u_scalar_byval_fn(vec_byval_fn)" }
attributes #5 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2v_scalar_fn_int_variant_attrs(vec_fn_int_variant_attrs)" }
attributes #6 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2u_scalar_fn_uniform_ptr_variant_attrs(vec_fn_uniform_ptr_variant_attrs)" }
attributes #7 = { nounwind willreturn memory(none) "vector-function-abi-variant"="_ZGVnN2v_scalar_fn_fp_variant_attrs(vec_fn_fp_variant_attrs)" }