Test Failure: Transforms/SROA/vector-promotion.ll

Test source: git

Comments: LLVM PR52971

Log:

Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
ERROR: Unsupported instruction:   %val0 = load ptr addrspace(3), ptr %init, align 8
-- 1. PassManager<Function> : Skipping NOP
-- 2. SROAPass

----------------------------------------
define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 3. SROAPass

----------------------------------------
define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %tmp1 = load i32, ptr %a.tmp1, align 8
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 16
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a.sroa.0.8.vec.extract = extractelement <4 x i32> %x, i32 2
  %a.sroa.2.28.vec.extract = extractelement <4 x i32> %y, i32 3
  %a.sroa.2.16.vec.extract = extractelement <4 x i32> %y, i32 0
  %tmp4 = add i32 %a.sroa.0.8.vec.extract, %a.sroa.2.28.vec.extract
  %tmp5 = add i32 %a.sroa.2.16.vec.extract, %tmp4
  ret i32 %tmp5
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. SROAPass

----------------------------------------
define i32 @test2(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3.vec = load <2 x i32>, ptr %a.tmp3, align 8
  %tmp3 = extractelement <2 x i32> %tmp3.vec, i32 0
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 7. SROAPass

----------------------------------------
define i32 @test2(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %tmp1 = load i32, ptr %a.tmp1, align 8
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3.vec = load <2 x i32>, ptr %a.tmp3, align 16
  %tmp3 = extractelement <2 x i32> %tmp3.vec, i32 0
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test2(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a.sroa.0.8.vec.extract = extractelement <4 x i32> %x, i32 2
  %a.sroa.2.28.vec.extract = extractelement <4 x i32> %y, i32 3
  %a.sroa.2.16.vec.extract = shufflevector <4 x i32> %y, <4 x i32> poison, 0, 1
  %tmp3 = extractelement <2 x i32> %a.sroa.2.16.vec.extract, i32 0
  %tmp4 = add i32 %a.sroa.0.8.vec.extract, %a.sroa.2.28.vec.extract
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. SROAPass

----------------------------------------
define i32 @test3(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memset ptr %a.y align 1, i8 0, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  memset ptr %a.tmp1 align 1, i8 255, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 11. SROAPass

----------------------------------------
define i32 @test3(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memset ptr %a.y align 16, i8 0, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  memset ptr %a.tmp1 align 8, i8 255, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 8
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 16
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test3(<4 x i32> %x, <4 x i32> %y) {
entry:
  %a.sroa.0.8.vec.insert = insertelement <4 x i32> %x, i32 4294967295, i32 2
  %a.sroa.0.8.vec.extract = extractelement <4 x i32> %a.sroa.0.8.vec.insert, i32 2
  %a.sroa.3.28.vec.extract = extractelement <4 x i32> { 0, 0, 0, 0 }, i32 3
  %a.sroa.3.16.vec.extract = extractelement <4 x i32> { 0, 0, 0, 0 }, i32 0
  %tmp4 = add i32 %a.sroa.0.8.vec.extract, %a.sroa.3.28.vec.extract
  %tmp5 = add i32 %a.sroa.3.16.vec.extract, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct!

-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. SROAPass

----------------------------------------
define i32 @test4(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memcpy ptr %a.y align 1, ptr %z align 1, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  memcpy ptr %a.tmp1 align 1, ptr %z.tmp1 align 1, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 15. SROAPass

----------------------------------------
define i32 @test4(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memcpy ptr %a.y align 16, ptr %z align 1, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  memcpy ptr %a.tmp1 align 8, ptr %z.tmp1 align 1, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 8
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 16
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test4(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %a.sroa.3.16.copyload = load <4 x i32>, ptr %z, align 1
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  %a.sroa.0.8.copyload = load i32, ptr %z.tmp1, align 1
  %a.sroa.0.8.vec.insert = insertelement <4 x i32> %x, i32 %a.sroa.0.8.copyload, i32 2
  %a.sroa.0.8.vec.extract = extractelement <4 x i32> %a.sroa.0.8.vec.insert, i32 2
  %a.sroa.3.28.vec.extract = extractelement <4 x i32> %a.sroa.3.16.copyload, i32 3
  %a.sroa.3.16.vec.extract = extractelement <4 x i32> %a.sroa.3.16.copyload, i32 0
  %tmp4 = add i32 %a.sroa.0.8.vec.extract, %a.sroa.3.28.vec.extract
  %tmp5 = add i32 %a.sroa.3.16.vec.extract, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct!

-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. SROAPass
-- 19. SROAPass
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. SROAPass

----------------------------------------
define i32 @test5(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memcpy ptr %a align 1, ptr %a.y align 1, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  memcpy ptr %z.tmp1 align 1, ptr %a.tmp1 align 1, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 23. SROAPass

----------------------------------------
define i32 @test5(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %a = alloca i64 32, align 16
  store <4 x i32> %x, ptr %a, align 16
  %a.y = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1
  store <4 x i32> %y, ptr %a.y, align 16
  memcpy ptr %a align 16, ptr %a.y align 16, i32 16
  %a.tmp1 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 0, 4 x i64 2
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  memcpy ptr %z.tmp1 align 1, ptr %a.tmp1 align 8, i32 4
  %tmp1 = load i32, ptr %a.tmp1, align 8
  %a.tmp2 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 3
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 32 x i64 0, 16 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 16
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test5(<4 x i32> %x, <4 x i32> %y, ptr %z) {
entry:
  %z.tmp1 = gep inbounds ptr %z, 16 x i64 0, 4 x i64 2
  %a.sroa.0.8.vec.extract3 = extractelement <4 x i32> %y, i32 2
  store i32 %a.sroa.0.8.vec.extract3, ptr %z.tmp1, align 1
  %a.sroa.0.8.vec.extract = extractelement <4 x i32> %y, i32 2
  %a.sroa.4.12.vec.extract = extractelement <4 x i32> %y, i32 3
  %a.sroa.4.0.vec.extract = extractelement <4 x i32> %y, i32 0
  %tmp4 = add i32 %a.sroa.0.8.vec.extract, %a.sroa.4.12.vec.extract
  %tmp5 = add i32 %a.sroa.4.0.vec.extract, %tmp4
  ret i32 %tmp5
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. SROAPass

----------------------------------------
define i64 @test6(<4 x i64> %x, <4 x i64> %y, i64 %n) {
#0:
  %tmp = alloca i64 64, align 32
  %p0 = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 0
  store <4 x i64> %x, ptr %p0, align 32
  %p1 = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 32
  store <4 x i64> %y, ptr %p1, align 32
  %addr = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 0, 8 x i64 %n
  %res = load i64, ptr %addr, align 4
  ret i64 %res
}
Transformation seems to be correct! (syntactically equal)

-- 27. SROAPass

----------------------------------------
define i64 @test6(<4 x i64> %x, <4 x i64> %y, i64 %n) {
#0:
  %tmp = alloca i64 64, align 32
  %p0 = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 0
  store <4 x i64> %x, ptr %p0, align 32
  %p1 = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 32
  store <4 x i64> %y, ptr %p1, align 32
  %addr = gep inbounds ptr %tmp, 64 x i32 0, 1 x i64 0, 8 x i64 %n
  %res = load i64, ptr %addr, align 4
  ret i64 %res
}
Transformation seems to be correct! (syntactically equal)

-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. SROAPass

----------------------------------------
define <4 x i32> @test_subvec_store() {
entry:
  %a = alloca i64 16, align 16
  store <2 x i32> { 0, 0 }, ptr %a, align 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  store <2 x i32> { 1, 1 }, ptr %a.gep1, align 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  store <2 x i32> { 2, 2 }, ptr %a.gep2, align 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  store i32 3, ptr %a.gep3, align 4
  %ret = load <4 x i32>, ptr %a, align 16
  ret <4 x i32> %ret
}
Transformation seems to be correct! (syntactically equal)

-- 31. SROAPass

----------------------------------------
define <4 x i32> @test_subvec_store() {
entry:
  %a = alloca i64 16, align 16
  store <2 x i32> { 0, 0 }, ptr %a, align 16
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  store <2 x i32> { 1, 1 }, ptr %a.gep1, align 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  store <2 x i32> { 2, 2 }, ptr %a.gep2, align 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  store i32 3, ptr %a.gep3, align 4
  %ret = load <4 x i32>, ptr %a, align 16
  ret <4 x i32> %ret
}
=>
define <4 x i32> @test_subvec_store() {
entry:
  %a.0.vecblend = select <4 x i1> { 1, 1, 0, 0 }, <4 x i32> { 0, 0, undef, undef }, <4 x i32> undef
  %a.4.vecblend = select <4 x i1> { 0, 1, 1, 0 }, <4 x i32> { undef, 1, 1, undef }, <4 x i32> %a.0.vecblend
  %a.8.vecblend = select <4 x i1> { 0, 0, 1, 1 }, <4 x i32> { undef, undef, 2, 2 }, <4 x i32> %a.4.vecblend
  %a.12.vec.insert = insertelement <4 x i32> %a.8.vecblend, i32 3, i32 3
  ret <4 x i32> %a.12.vec.insert
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. SROAPass

----------------------------------------
define <4 x i32> @test_subvec_load() {
entry:
  %a = alloca i64 16, align 16
  store <4 x i32> { 0, 1, 2, 3 }, ptr %a, align 16
  %first = load <2 x i32>, ptr %a, align 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  %second = load <2 x i32>, ptr %a.gep1, align 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  %third = load <2 x i32>, ptr %a.gep2, align 8
  %tmp = shufflevector <2 x i32> %first, <2 x i32> %second, 0, 2
  %ret = shufflevector <2 x i32> %tmp, <2 x i32> %third, 0, 1, 2, 3
  ret <4 x i32> %ret
}
Transformation seems to be correct! (syntactically equal)

-- 35. SROAPass

----------------------------------------
define <4 x i32> @test_subvec_load() {
entry:
  %a = alloca i64 16, align 16
  store <4 x i32> { 0, 1, 2, 3 }, ptr %a, align 16
  %first = load <2 x i32>, ptr %a, align 16
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  %second = load <2 x i32>, ptr %a.gep1, align 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  %third = load <2 x i32>, ptr %a.gep2, align 8
  %tmp = shufflevector <2 x i32> %first, <2 x i32> %second, 0, 2
  %ret = shufflevector <2 x i32> %tmp, <2 x i32> %third, 0, 1, 2, 3
  ret <4 x i32> %ret
}
=>
define <4 x i32> @test_subvec_load() {
entry:
  %a.0.vec.extract = shufflevector <4 x i32> { 0, 1, 2, 3 }, <4 x i32> poison, 0, 1
  %a.4.vec.extract = shufflevector <4 x i32> { 0, 1, 2, 3 }, <4 x i32> poison, 1, 2
  %a.8.vec.extract = shufflevector <4 x i32> { 0, 1, 2, 3 }, <4 x i32> poison, 2, 3
  %tmp = shufflevector <2 x i32> %a.0.vec.extract, <2 x i32> %a.4.vec.extract, 0, 2
  %ret = shufflevector <2 x i32> %tmp, <2 x i32> %a.8.vec.extract, 0, 1, 2, 3
  ret <4 x i32> %ret
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. SROAPass

----------------------------------------
define <4 x float> @test_subvec_memset() {
entry:
  %a = alloca i64 16, align 16
  memset ptr %a align 1, i8 0, i32 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  memset ptr %a.gep1 align 1, i8 1, i32 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  memset ptr %a.gep2 align 1, i8 3, i32 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  memset ptr %a.gep3 align 1, i8 7, i32 4
  %ret = load <4 x float>, ptr %a, align 16
  ret <4 x float> %ret
}
Transformation seems to be correct! (syntactically equal)

-- 39. SROAPass

----------------------------------------
define <4 x float> @test_subvec_memset() {
entry:
  %a = alloca i64 16, align 16
  memset ptr %a align 16, i8 0, i32 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  memset ptr %a.gep1 align 4, i8 1, i32 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  memset ptr %a.gep2 align 8, i8 3, i32 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  memset ptr %a.gep3 align 4, i8 7, i32 4
  %ret = load <4 x float>, ptr %a, align 16
  ret <4 x float> %ret
}
=>
define <4 x float> @test_subvec_memset() {
entry:
  %a.0.vecblend = select <4 x i1> { 1, 1, 0, 0 }, <4 x float> { 0.000000, 0.000000, undef, undef }, <4 x float> undef
  %a.4.vecblend = select <4 x i1> { 0, 1, 1, 0 }, <4 x float> { undef, 0.000000, 0.000000, undef }, <4 x float> %a.0.vecblend
  %a.8.vecblend = select <4 x i1> { 0, 0, 1, 1 }, <4 x float> { undef, undef, 0.000000, 0.000000 }, <4 x float> %a.4.vecblend
  %a.12.vec.insert = insertelement <4 x float> %a.8.vecblend, float 0.000000, i32 3
  ret <4 x float> %a.12.vec.insert
}
Transformation seems to be correct!

-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. SROAPass

----------------------------------------
define <4 x float> @test_subvec_memcpy(ptr %x, ptr %y, ptr %z, ptr %f, ptr %out) {
entry:
  %a = alloca i64 16, align 16
  memcpy ptr %a align 1, ptr %x align 1, i32 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  memcpy ptr %a.gep1 align 1, ptr %y align 1, i32 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  memcpy ptr %a.gep2 align 1, ptr %z align 1, i32 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  memcpy ptr %a.gep3 align 1, ptr %f align 1, i32 4
  memcpy ptr %out align 1, ptr %a.gep2 align 1, i32 8
  %ret = load <4 x float>, ptr %a, align 16
  ret <4 x float> %ret
}
Transformation seems to be correct! (syntactically equal)

-- 43. SROAPass

----------------------------------------
define <4 x float> @test_subvec_memcpy(ptr %x, ptr %y, ptr %z, ptr %f, ptr %out) {
entry:
  %a = alloca i64 16, align 16
  memcpy ptr %a align 16, ptr %x align 1, i32 8
  %a.gep1 = gep ptr %a, 16 x i32 0, 4 x i32 1
  memcpy ptr %a.gep1 align 4, ptr %y align 1, i32 8
  %a.gep2 = gep ptr %a, 16 x i32 0, 4 x i32 2
  memcpy ptr %a.gep2 align 8, ptr %z align 1, i32 8
  %a.gep3 = gep ptr %a, 16 x i32 0, 4 x i32 3
  memcpy ptr %a.gep3 align 4, ptr %f align 1, i32 4
  memcpy ptr %out align 1, ptr %a.gep2 align 8, i32 8
  %ret = load <4 x float>, ptr %a, align 16
  ret <4 x float> %ret
}
=>
define <4 x float> @test_subvec_memcpy(ptr %x, ptr %y, ptr %z, ptr %f, ptr %out) {
entry:
  %a.0.copyload = load <2 x float>, ptr %x, align 1
  %a.0.vec.expand = shufflevector <2 x float> %a.0.copyload, <2 x float> poison, 0, 1, 4294967295, 4294967295
  %a.0.vecblend = select <4 x i1> { 1, 1, 0, 0 }, <4 x float> %a.0.vec.expand, <4 x float> undef
  %a.4.copyload = load <2 x float>, ptr %y, align 1
  %a.4.vec.expand = shufflevector <2 x float> %a.4.copyload, <2 x float> poison, 4294967295, 0, 1, 4294967295
  %a.4.vecblend = select <4 x i1> { 0, 1, 1, 0 }, <4 x float> %a.4.vec.expand, <4 x float> %a.0.vecblend
  %a.8.copyload = load <2 x float>, ptr %z, align 1
  %a.8.vec.expand = shufflevector <2 x float> %a.8.copyload, <2 x float> poison, 4294967295, 4294967295, 0, 1
  %a.8.vecblend = select <4 x i1> { 0, 0, 1, 1 }, <4 x float> %a.8.vec.expand, <4 x float> %a.4.vecblend
  %a.12.copyload = load float, ptr %f, align 1
  %a.12.vec.insert = insertelement <4 x float> %a.8.vecblend, float %a.12.copyload, i32 3
  %a.8.vec.extract = shufflevector <4 x float> %a.12.vec.insert, <4 x float> poison, 2, 3
  store <2 x float> %a.8.vec.extract, ptr %out, align 1
  ret <4 x float> %a.12.vec.insert
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. SROAPass

----------------------------------------
define i32 @PR14212(<3 x i8> %val) {
entry:
  %retval = alloca i64 4, align 4
  store <3 x i8> %val, ptr %retval, align 4
  %load = load i32, ptr %retval, align 4
  ret i32 %load
}
Transformation seems to be correct! (syntactically equal)

-- 47. SROAPass

----------------------------------------
define i32 @PR14212(<3 x i8> %val) {
entry:
  %retval = alloca i64 4, align 4
  store <3 x i8> %val, ptr %retval, align 4
  %load = load i32, ptr %retval, align 4
  ret i32 %load
}
=>
define i32 @PR14212(<3 x i8> %val) {
entry:
  %#0 = bitcast <3 x i8> %val to i24
  %retval.sroa.2.0.insert.ext = zext i8 undef to i32
  %retval.sroa.2.0.insert.shift = shl i32 %retval.sroa.2.0.insert.ext, 24
  %retval.sroa.2.0.insert.mask = and i32 undef, 16777215
  %retval.sroa.2.0.insert.insert = or i32 %retval.sroa.2.0.insert.mask, %retval.sroa.2.0.insert.shift
  %retval.0.insert.ext = zext i24 %#0 to i32
  %retval.0.insert.mask = and i32 %retval.sroa.2.0.insert.insert, 4278190080
  %retval.0.insert.insert = or i32 %retval.0.insert.mask, %retval.0.insert.ext
  ret i32 %retval.0.insert.insert
}
Transformation seems to be correct!

-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. SROAPass

----------------------------------------
define <2 x i8> @PR14349.1(i32 %x) {
entry:
  %a = alloca i64 4, align 4
  store i32 %x, ptr %a, align 4
  %vec = load <2 x i8>, ptr %a, align 2
  ret <2 x i8> %vec
}
Transformation seems to be correct! (syntactically equal)

-- 51. SROAPass

----------------------------------------
define <2 x i8> @PR14349.1(i32 %x) {
entry:
  %a = alloca i64 4, align 4
  store i32 %x, ptr %a, align 4
  %vec = load <2 x i8>, ptr %a, align 4
  ret <2 x i8> %vec
}
=>
define <2 x i8> @PR14349.1(i32 %x) {
entry:
  %a.sroa.0.0.extract.trunc = trunc i32 %x to i16
  %#0 = bitcast i16 %a.sroa.0.0.extract.trunc to <2 x i8>
  ret <2 x i8> %#0
}
Transformation seems to be correct!

-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. SROAPass

----------------------------------------
define i32 @PR14349.2(<2 x i8> %x) {
entry:
  %a = alloca i64 4, align 4
  store <2 x i8> %x, ptr %a, align 2
  %int = load i32, ptr %a, align 4
  ret i32 %int
}
Transformation seems to be correct! (syntactically equal)

-- 55. SROAPass

----------------------------------------
define i32 @PR14349.2(<2 x i8> %x) {
entry:
  %a = alloca i64 4, align 4
  store <2 x i8> %x, ptr %a, align 4
  %int = load i32, ptr %a, align 4
  ret i32 %int
}
=>
define i32 @PR14349.2(<2 x i8> %x) {
entry:
  %#0 = bitcast <2 x i8> %x to i16
  %a.sroa.2.0.insert.ext = zext i16 undef to i32
  %a.sroa.2.0.insert.shift = shl i32 %a.sroa.2.0.insert.ext, 16
  %a.sroa.2.0.insert.mask = and i32 undef, 65535
  %a.sroa.2.0.insert.insert = or i32 %a.sroa.2.0.insert.mask, %a.sroa.2.0.insert.shift
  %a.sroa.0.0.insert.ext = zext i16 %#0 to i32
  %a.sroa.0.0.insert.mask = and i32 %a.sroa.2.0.insert.insert, 4294901760
  %a.sroa.0.0.insert.insert = or i32 %a.sroa.0.0.insert.mask, %a.sroa.0.0.insert.ext
  ret i32 %a.sroa.0.0.insert.insert
}
Transformation seems to be correct!

-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. SROAPass

----------------------------------------
define i32 @test7(<2 x i32> %x, <2 x i32> %y) {
entry:
  %a = alloca i64 16, align 8
  store <2 x i32> %x, ptr %a, align 8
  %a.y = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1
  store <2 x i32> %y, ptr %a.y, align 8
  %a.tmp1 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 0, 4 x i64 1
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1, 4 x i64 1
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
Transformation seems to be correct! (syntactically equal)

-- 59. SROAPass

----------------------------------------
define i32 @test7(<2 x i32> %x, <2 x i32> %y) {
entry:
  %a = alloca i64 16, align 8
  store <2 x i32> %x, ptr %a, align 8
  %a.y = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1
  store <2 x i32> %y, ptr %a.y, align 8
  %a.tmp1 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 0, 4 x i64 1
  %tmp1 = load i32, ptr %a.tmp1, align 4
  %a.tmp2 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1, 4 x i64 1
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %a.tmp3 = gep inbounds ptr %a, 16 x i64 0, 8 x i64 1, 4 x i64 0
  %tmp3 = load i32, ptr %a.tmp3, align 8
  %tmp4 = add i32 %tmp1, %tmp2
  %tmp5 = add i32 %tmp3, %tmp4
  ret i32 %tmp5
}
=>
define i32 @test7(<2 x i32> %x, <2 x i32> %y) {
entry:
  %a.sroa.0.4.vec.extract = extractelement <2 x i32> %x, i32 1
  %a.sroa.2.12.vec.extract = extractelement <2 x i32> %y, i32 1
  %a.sroa.2.8.vec.extract = extractelement <2 x i32> %y, i32 0
  %tmp4 = add i32 %a.sroa.0.4.vec.extract, %a.sroa.2.12.vec.extract
  %tmp5 = add i32 %a.sroa.2.8.vec.extract, %tmp4
  ret i32 %tmp5
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. SROAPass

----------------------------------------
define i32 @test8(<2 x i32> %x) {
entry:
  %a = alloca i64 8, align 8
  store <2 x i32> %x, ptr %a, align 8
  %tmp1 = load i32, ptr %a, align 4
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  ret i32 %tmp4
}
Transformation seems to be correct! (syntactically equal)

-- 63. SROAPass

----------------------------------------
define i32 @test8(<2 x i32> %x) {
entry:
  %a = alloca i64 8, align 8
  store <2 x i32> %x, ptr %a, align 8
  %tmp1 = load i32, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  %tmp2 = load i32, ptr %a.tmp2, align 4
  %tmp4 = add i32 %tmp1, %tmp2
  ret i32 %tmp4
}
=>
define i32 @test8(<2 x i32> %x) {
entry:
  %a.sroa.0.0.vec.extract = extractelement <2 x i32> %x, i32 0
  %a.sroa.0.4.vec.extract = extractelement <2 x i32> %x, i32 1
  %tmp4 = add i32 %a.sroa.0.0.vec.extract, %a.sroa.0.4.vec.extract
  ret i32 %tmp4
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. SROAPass

----------------------------------------
define <2 x i32> @test9(i32 %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store i32 %x, ptr %a, align 4
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x i32>, ptr %a, align 8
  ret <2 x i32> %result
}
Transformation seems to be correct! (syntactically equal)

-- 67. SROAPass

----------------------------------------
define <2 x i32> @test9(i32 %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store i32 %x, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x i32>, ptr %a, align 8
  ret <2 x i32> %result
}
=>
define <2 x i32> @test9(i32 %x, i32 %y) {
entry:
  %a.sroa.0.0.vec.insert = insertelement <2 x i32> undef, i32 %x, i32 0
  %a.sroa.0.4.vec.insert = insertelement <2 x i32> %a.sroa.0.0.vec.insert, i32 %y, i32 1
  ret <2 x i32> %a.sroa.0.4.vec.insert
}
Transformation seems to be correct!

-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. SROAPass

----------------------------------------
define <2 x i32> @test10(<4 x i16> %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store <4 x i16> %x, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x i32>, ptr %a, align 8
  ret <2 x i32> %result
}
Transformation seems to be correct! (syntactically equal)

-- 71. SROAPass

----------------------------------------
define <2 x i32> @test10(<4 x i16> %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store <4 x i16> %x, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x i32>, ptr %a, align 8
  ret <2 x i32> %result
}
=>
define <2 x i32> @test10(<4 x i16> %x, i32 %y) {
entry:
  %#0 = bitcast <4 x i16> %x to <2 x i32>
  %a.sroa.0.4.vec.insert = insertelement <2 x i32> %#0, i32 %y, i32 1
  ret <2 x i32> %a.sroa.0.4.vec.insert
}
Transformation seems to be correct!

-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. SROAPass

----------------------------------------
define <2 x float> @test11(<4 x i16> %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store <4 x i16> %x, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x float>, ptr %a, align 8
  ret <2 x float> %result
}
Transformation seems to be correct! (syntactically equal)

-- 75. SROAPass

----------------------------------------
define <2 x float> @test11(<4 x i16> %x, i32 %y) {
entry:
  %a = alloca i64 8, align 8
  store <4 x i16> %x, ptr %a, align 8
  %a.tmp2 = gep inbounds ptr %a, 4 x i64 1
  store i32 %y, ptr %a.tmp2, align 4
  %result = load <2 x float>, ptr %a, align 8
  ret <2 x float> %result
}
=>
define <2 x float> @test11(<4 x i16> %x, i32 %y) {
entry:
  %#0 = bitcast <4 x i16> %x to <2 x i32>
  %a.sroa.0.4.vec.insert = insertelement <2 x i32> %#0, i32 %y, i32 1
  %#1 = bitcast <2 x i32> %a.sroa.0.4.vec.insert to <2 x float>
  ret <2 x float> %#1
}
Transformation seems to be correct!

-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. SROAPass

----------------------------------------
define <4 x float> @test12(<4 x i32> %val) {
#0:
  %a = alloca i64 16, align 16
  store <4 x i32> %val, ptr %a, align 16
  %vec = load <4 x float>, ptr %a, align 16
  ret <4 x float> %vec
}
Transformation seems to be correct! (syntactically equal)

-- 79. SROAPass

----------------------------------------
define <4 x float> @test12(<4 x i32> %val) {
#0:
  %a = alloca i64 16, align 16
  store <4 x i32> %val, ptr %a, align 16
  %vec = load <4 x float>, ptr %a, align 16
  ret <4 x float> %vec
}
=>
define <4 x float> @test12(<4 x i32> %val) {
#0:
  %#1 = bitcast <4 x i32> %val to <4 x float>
  ret <4 x float> %#1
}
Transformation seems to be correct!

-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. SROAPass

----------------------------------------
define <2 x i64> @test13(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x = alloca i64 16, align 4
  store i32 %a, ptr %x, align 4
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 4 x i64 2
  store i32 %c, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x, 4 x i64 3
  store i32 %d, ptr %x.tmp4, align 4
  %result = load <2 x i64>, ptr %x, align 16
  ret <2 x i64> %result
}
Transformation seems to be correct! (syntactically equal)

-- 83. SROAPass

----------------------------------------
define <2 x i64> @test13(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x = alloca i64 16, align 4
  store i32 %a, ptr %x, align 4
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 4 x i64 2
  store i32 %c, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x, 4 x i64 3
  store i32 %d, ptr %x.tmp4, align 4
  %result = load <2 x i64>, ptr %x, align 16
  ret <2 x i64> %result
}
=>
define <2 x i64> @test13(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x.sroa.0.0.vec.insert = insertelement <4 x i32> undef, i32 %a, i32 0
  %x.sroa.0.4.vec.insert = insertelement <4 x i32> %x.sroa.0.0.vec.insert, i32 %b, i32 1
  %x.sroa.0.8.vec.insert = insertelement <4 x i32> %x.sroa.0.4.vec.insert, i32 %c, i32 2
  %x.sroa.0.12.vec.insert = insertelement <4 x i32> %x.sroa.0.8.vec.insert, i32 %d, i32 3
  %#0 = bitcast <4 x i32> %x.sroa.0.12.vec.insert to <2 x i64>
  ret <2 x i64> %#0
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. SROAPass

----------------------------------------
define i32 @test14(<2 x i64> %x) {
entry:
  %x.addr = alloca i64 16, align 16
  store <2 x i64> %x, ptr %x.addr, align 16
  %x.cast = bitcast ptr %x.addr to ptr
  %a = load i32, ptr %x.cast, align 4
  %x.tmp2 = gep inbounds ptr %x.cast, 4 x i64 1
  %b = load i32, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x.cast, 4 x i64 2
  %c = load i32, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x.cast, 4 x i64 3
  %d = load i32, ptr %x.tmp4, align 4
  %add = add i32 %a, %b
  %add1 = add i32 %c, %d
  %add2 = add i32 %add, %add1
  ret i32 %add2
}
Transformation seems to be correct! (syntactically equal)

-- 87. SROAPass

----------------------------------------
define i32 @test14(<2 x i64> %x) {
entry:
  %x.addr = alloca i64 16, align 16
  store <2 x i64> %x, ptr %x.addr, align 16
  %x.cast = bitcast ptr %x.addr to ptr
  %a = load i32, ptr %x.cast, align 4
  %x.tmp2 = gep inbounds ptr %x.cast, 4 x i64 1
  %b = load i32, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x.cast, 4 x i64 2
  %c = load i32, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x.cast, 4 x i64 3
  %d = load i32, ptr %x.tmp4, align 4
  %add = add i32 %a, %b
  %add1 = add i32 %c, %d
  %add2 = add i32 %add, %add1
  ret i32 %add2
}
=>
define i32 @test14(<2 x i64> %x) {
entry:
  %#0 = bitcast <2 x i64> %x to <4 x i32>
  %x.addr.sroa.0.0.vec.extract = extractelement <4 x i32> %#0, i32 0
  %x.addr.sroa.0.4.vec.extract = extractelement <4 x i32> %#0, i32 1
  %x.addr.sroa.0.8.vec.extract = extractelement <4 x i32> %#0, i32 2
  %x.addr.sroa.0.12.vec.extract = extractelement <4 x i32> %#0, i32 3
  %add = add i32 %x.addr.sroa.0.0.vec.extract, %x.addr.sroa.0.4.vec.extract
  %add1 = add i32 %x.addr.sroa.0.8.vec.extract, %x.addr.sroa.0.12.vec.extract
  %add2 = add i32 %add, %add1
  ret i32 %add2
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. SROAPass

----------------------------------------
define <4 x ptr> @test15(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x = alloca i64 32, align 8
  store i32 %a, ptr %x, align 4
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 4 x i64 2
  store i32 %c, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x, 4 x i64 3
  store i32 %d, ptr %x.tmp4, align 4
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
Transformation seems to be correct! (syntactically equal)

-- 91. SROAPass

----------------------------------------
define <4 x ptr> @test15(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x = alloca i64 32, align 8
  store i32 %a, ptr %x, align 8
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 4 x i64 2
  store i32 %c, ptr %x.tmp3, align 8
  %x.tmp4 = gep inbounds ptr %x, 4 x i64 3
  store i32 %d, ptr %x.tmp4, align 4
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
=>
define <4 x ptr> @test15(i32 %a, i32 %b, i32 %c, i32 %d) {
entry:
  %x.sroa.0 = alloca i64 32, align 32
  store i32 %a, ptr %x.sroa.0, align 32
  %x.sroa.0.4.x.tmp2.sroa_idx1 = gep inbounds ptr %x.sroa.0, 1 x i64 4
  store i32 %b, ptr %x.sroa.0.4.x.tmp2.sroa_idx1, align 4
  %x.sroa.0.8.x.tmp3.sroa_idx2 = gep inbounds ptr %x.sroa.0, 1 x i64 8
  store i32 %c, ptr %x.sroa.0.8.x.tmp3.sroa_idx2, align 8
  %x.sroa.0.12.x.tmp4.sroa_idx3 = gep inbounds ptr %x.sroa.0, 1 x i64 12
  store i32 %d, ptr %x.sroa.0.12.x.tmp4.sroa_idx3, align 4
  %x.sroa.0.0.x.sroa.0.0.result = load <4 x ptr>, ptr %x.sroa.0, align 32
  ret <4 x ptr> %x.sroa.0.0.x.sroa.0.0.result
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. SROAPass

----------------------------------------
define <4 x ptr> @test16(i64 %a, i64 %b, i64 %c, i64 %d) {
entry:
  %x = alloca i64 32, align 8
  store i64 %a, ptr %x, align 4
  %x.tmp2 = gep inbounds ptr %x, 8 x i64 1
  store i64 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 8 x i64 2
  store i64 %c, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x, 8 x i64 3
  store i64 %d, ptr %x.tmp4, align 4
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
Transformation seems to be correct! (syntactically equal)

-- 95. SROAPass

----------------------------------------
define <4 x ptr> @test16(i64 %a, i64 %b, i64 %c, i64 %d) {
entry:
  %x = alloca i64 32, align 8
  store i64 %a, ptr %x, align 8
  %x.tmp2 = gep inbounds ptr %x, 8 x i64 1
  store i64 %b, ptr %x.tmp2, align 8
  %x.tmp3 = gep inbounds ptr %x, 8 x i64 2
  store i64 %c, ptr %x.tmp3, align 8
  %x.tmp4 = gep inbounds ptr %x, 8 x i64 3
  store i64 %d, ptr %x.tmp4, align 8
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
=>
define <4 x ptr> @test16(i64 %a, i64 %b, i64 %c, i64 %d) {
entry:
  %#0 = int2ptr i64 %a to ptr
  %x.sroa.0.0.vec.insert = insertelement <4 x ptr> undef, ptr %#0, i32 0
  %#1 = int2ptr i64 %b to ptr
  %x.sroa.0.8.vec.insert = insertelement <4 x ptr> %x.sroa.0.0.vec.insert, ptr %#1, i32 1
  %#2 = int2ptr i64 %c to ptr
  %x.sroa.0.16.vec.insert = insertelement <4 x ptr> %x.sroa.0.8.vec.insert, ptr %#2, i32 2
  %#3 = int2ptr i64 %d to ptr
  %x.sroa.0.24.vec.insert = insertelement <4 x ptr> %x.sroa.0.16.vec.insert, ptr %#3, i32 3
  ret <4 x ptr> %x.sroa.0.24.vec.insert
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. SROAPass

----------------------------------------
define <4 x ptr> @test17(i32 %a, i32 %b, i64 %c, i64 %d) {
entry:
  %x = alloca i64 32, align 8
  store i32 %a, ptr %x, align 4
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 8 x i64 2
  store i64 %c, ptr %x.tmp3, align 4
  %x.tmp4 = gep inbounds ptr %x, 8 x i64 3
  store i64 %d, ptr %x.tmp4, align 4
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
Transformation seems to be correct! (syntactically equal)

-- 99. SROAPass

----------------------------------------
define <4 x ptr> @test17(i32 %a, i32 %b, i64 %c, i64 %d) {
entry:
  %x = alloca i64 32, align 8
  store i32 %a, ptr %x, align 8
  %x.tmp2 = gep inbounds ptr %x, 4 x i64 1
  store i32 %b, ptr %x.tmp2, align 4
  %x.tmp3 = gep inbounds ptr %x, 8 x i64 2
  store i64 %c, ptr %x.tmp3, align 8
  %x.tmp4 = gep inbounds ptr %x, 8 x i64 3
  store i64 %d, ptr %x.tmp4, align 8
  %result = load <4 x ptr>, ptr %x, align 32
  ret <4 x ptr> %result
}
=>
define <4 x ptr> @test17(i32 %a, i32 %b, i64 %c, i64 %d) {
entry:
  %x.sroa.0 = alloca i64 32, align 32
  store i32 %a, ptr %x.sroa.0, align 32
  %x.sroa.0.4.x.tmp2.sroa_idx1 = gep inbounds ptr %x.sroa.0, 1 x i64 4
  store i32 %b, ptr %x.sroa.0.4.x.tmp2.sroa_idx1, align 4
  %x.sroa.0.16.x.tmp3.sroa_idx2 = gep inbounds ptr %x.sroa.0, 1 x i64 16
  store i64 %c, ptr %x.sroa.0.16.x.tmp3.sroa_idx2, align 16
  %x.sroa.0.24.x.tmp4.sroa_idx3 = gep inbounds ptr %x.sroa.0, 1 x i64 24
  store i64 %d, ptr %x.sroa.0.24.x.tmp4.sroa_idx3, align 8
  %x.sroa.0.0.x.sroa.0.0.result = load <4 x ptr>, ptr %x.sroa.0, align 32
  ret <4 x ptr> %x.sroa.0.0.x.sroa.0.0.result
}

****************************************
WARNING: Source function is always UB.
It can be refined by any target function.
Please make sure this is what you wanted.
****************************************

Transformation seems to be correct!

-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. SROAPass

----------------------------------------
define i1 @test18() {
#0:
  %a = alloca i64 32, align 32
  store <2 x i64> { 0, -1 }, ptr %a, align 16
  %l = load i1, ptr %a, align 1
  ret i1 %l
}
Transformation seems to be correct! (syntactically equal)

-- 103. SROAPass

----------------------------------------
define i1 @test18() {
#0:
  %a = alloca i64 32, align 32
  store <2 x i64> { 0, -1 }, ptr %a, align 32
  %l = load i1, ptr %a, align 32
  ret i1 %l
}
=>
define i1 @test18() {
#0:
  %a.sroa.0 = alloca i64 16, align 32
  store <2 x i64> { 0, -1 }, ptr %a.sroa.0, align 32
  %a.sroa.0.0.a.sroa.0.0.l = load i1, ptr %a.sroa.0, align 32
  ret i1 %a.sroa.0.0.a.sroa.0.0.l
}
Transformation seems to be correct!

-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. SROAPass

----------------------------------------
define void @swap-8bytes(ptr %x, ptr %y) {
#0:
  %tmp = alloca i64 8, align 4
  memcpy ptr %tmp align 1, ptr %x align 1, i64 8
  memcpy ptr %x align 1, ptr %y align 1, i64 8
  memcpy ptr %y align 1, ptr %tmp align 1, i64 8
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 107. SROAPass

----------------------------------------
define void @swap-8bytes(ptr %x, ptr %y) {
#0:
  %tmp = alloca i64 8, align 4
  memcpy ptr %tmp align 4, ptr %x align 1, i64 8
  memcpy ptr %x align 1, ptr %y align 1, i64 8
  memcpy ptr %y align 1, ptr %tmp align 4, i64 8
  ret void
}
=>
define void @swap-8bytes(ptr %x, ptr %y) {
#0:
  %tmp.sroa.0.0.copyload = load i64, ptr %x, align 1
  memcpy ptr %x align 1, ptr %y align 1, i64 8
  store i64 %tmp.sroa.0.0.copyload, ptr %y, align 1
  ret void
}
Transformation doesn't verify! (unsound)
ERROR: Mismatch in memory

Example:
ptr %x = pointer(non-local, block_id=1, offset=0)
ptr %y = pointer(non-local, block_id=1, offset=0)

Source:
ptr %tmp = null

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 0	align: 1	alloc type: 0	alive: false	address: 0
Block 1 >	size: 15	align: 4	alloc type: 0	alive: true	address: 4
Contents:
3: poison
*: #x00

Block 2 >	size: 1	align: 1	alloc type: 0	alive: true	address: 2
Contents:
*: pointer(non-local, block_id=2, offset=0), byte offset=0


LOCAL BLOCKS:
Block 4 >	size: 8	align: 4	alloc type: 1	alive: true

Target:
i64 %tmp.sroa.0.0.copyload = poison

Mismatch in pointer(non-local, block_id=1, offset=0)
Source value: #x00
Target value: poison

Pass: SROAPass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-passes=sroa<preserve-cfg>' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_rqpNt6JC_TKQS.bc"


------------------- SMT STATS -------------------
Num queries: 110
Num invalid: 0
Num skips:   0
Num trivial: 115 (51.1%)
Num timeout: 7 (6.4%)
Num errors:  0 (0.0%)
Num SAT:     60 (54.5%)
Num UNSAT:   43 (39.1%)
Alive2: Transform doesn't verify; aborting!

stderr:

RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/SROA/vector-promotion.ll -passes='sroa<preserve-cfg>' -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/SROA/vector-promotion.ll --check-prefixes=CHECK,CHECK-PRESERVE-CFG
+ /home/nlopes/alive2/build/opt-alive.sh '-passes=sroa<preserve-cfg>' -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/SROA/vector-promotion.ll --check-prefixes=CHECK,CHECK-PRESERVE-CFG

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/SROA/vector-promotion.ll --check-prefixes=CHECK,CHECK-PRESERVE-CFG

<-- Back