Test source: git
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
ERROR: Unsupported type: <vscale x 1 x i1>
ERROR: Unsupported type: <vscale x 1 x i64>
ERROR: Unsupported type: <vscale x 2 x i64>
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass
----------------------------------------
define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%f = sext i1 %e to i32
%g = and i32 %c, %f
%h = xor i32 %f, 4294967295
%i = and i32 %d, %h
%j = or i32 %g, %i
ret i32 %j
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstCombinePass
----------------------------------------
define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%f = sext i1 %e to i32
%g = and i32 %c, %f
%h = xor i32 %f, 4294967295
%i = and i32 %d, %h
%j = or i32 %g, %i
ret i32 %j
}
=>
define i32 @foo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%j = select i1 %e, i32 %c, i32 %d
ret i32 %j
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass
----------------------------------------
define i32 @bar(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%f = sext i1 %e to i32
%g = and i32 %c, %f
%h = xor i32 %f, 4294967295
%i = and i32 %d, %h
%j = or i32 %i, %g
ret i32 %j
}
Transformation seems to be correct! (syntactically equal)
-- 7. InstCombinePass
----------------------------------------
define i32 @bar(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%f = sext i1 %e to i32
%g = and i32 %c, %f
%h = xor i32 %f, 4294967295
%i = and i32 %d, %h
%j = or i32 %i, %g
ret i32 %j
}
=>
define i32 @bar(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%e = icmp slt i32 %a, %b
%j = select i1 %e, i32 %c, i32 %d
ret i32 %j
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass
----------------------------------------
define i32 @goo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.0.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.0.0, %c
%not = xor i32 %iftmp.0.0, 4294967295
%t2 = and i32 %not, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
Transformation seems to be correct! (syntactically equal)
-- 11. InstCombinePass
----------------------------------------
define i32 @goo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.0.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.0.0, %c
%not = xor i32 %iftmp.0.0, 4294967295
%t2 = and i32 %not, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
=>
define i32 @goo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%t3 = select i1 %t0, i32 %c, i32 %d
ret i32 %t3
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass
----------------------------------------
define i32 @poo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.0.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.0.0, %c
%iftmp = select i1 %t0, i32 0, i32 4294967295
%t2 = and i32 %iftmp, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
Transformation seems to be correct! (syntactically equal)
-- 15. InstCombinePass
----------------------------------------
define i32 @poo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.0.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.0.0, %c
%iftmp = select i1 %t0, i32 0, i32 4294967295
%t2 = and i32 %iftmp, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
=>
define i32 @poo(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0.not = icmp slt i32 %a, %b
%t3 = select i1 %t0.not, i32 %c, i32 %d
ret i32 %t3
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass
----------------------------------------
define i32 @fold_inverted_icmp_preds(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 %c, i32 0
%cmp2 = icmp sge i32 %a, %b
%sel2 = select i1 %cmp2, i32 %d, i32 0
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation seems to be correct! (syntactically equal)
-- 19. InstCombinePass
----------------------------------------
define i32 @fold_inverted_icmp_preds(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 %c, i32 0
%cmp2 = icmp sge i32 %a, %b
%sel2 = select i1 %cmp2, i32 %d, i32 0
%or = or i32 %sel1, %sel2
ret i32 %or
}
=>
define i32 @fold_inverted_icmp_preds(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 %c, i32 0
%cmp2.not = icmp slt i32 %a, %b
%sel2 = select i1 %cmp2.not, i32 0, i32 %d
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass
----------------------------------------
define i32 @fold_inverted_icmp_preds_reverse(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 0, i32 %c
%cmp2 = icmp sge i32 %a, %b
%sel2 = select i1 %cmp2, i32 0, i32 %d
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstCombinePass
----------------------------------------
define i32 @fold_inverted_icmp_preds_reverse(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 0, i32 %c
%cmp2 = icmp sge i32 %a, %b
%sel2 = select i1 %cmp2, i32 0, i32 %d
%or = or i32 %sel1, %sel2
ret i32 %or
}
=>
define i32 @fold_inverted_icmp_preds_reverse(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%cmp1 = icmp slt i32 %a, %b
%sel1 = select i1 %cmp1, i32 0, i32 %c
%cmp2.not = icmp slt i32 %a, %b
%sel2 = select i1 %cmp2.not, i32 %d, i32 0
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation seems to be correct!
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstCombinePass
----------------------------------------
define i32 @fold_inverted_fcmp_preds(float %a, float %b, i32 %c, i32 %d) {
#0:
%cmp1 = fcmp olt float %a, %b
%sel1 = select i1 %cmp1, i32 %c, i32 0
%cmp2 = fcmp uge float %a, %b
%sel2 = select i1 %cmp2, i32 %d, i32 0
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstCombinePass
----------------------------------------
define i32 @fold_inverted_fcmp_preds(float %a, float %b, i32 %c, i32 %d) {
#0:
%cmp1 = fcmp olt float %a, %b
%sel1 = select i1 %cmp1, i32 %c, i32 0
%cmp2 = fcmp uge float %a, %b
%sel2 = select i1 %cmp2, i32 %d, i32 0
%or = or i32 %sel1, %sel2
ret i32 %or
}
Transformation seems to be correct! (syntactically equal)
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstCombinePass
----------------------------------------
define <2 x i32> @fold_inverted_icmp_vector_preds(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c, <2 x i32> %d) {
#0:
%cmp1 = icmp ne <2 x i32> %a, %b
%sel1 = select <2 x i1> %cmp1, <2 x i32> %c, <2 x i32> { 0, 0 }
%cmp2 = icmp eq <2 x i32> %a, %b
%sel2 = select <2 x i1> %cmp2, <2 x i32> %d, <2 x i32> { 0, 0 }
%or = or <2 x i32> %sel1, %sel2
ret <2 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 31. InstCombinePass
----------------------------------------
define <2 x i32> @fold_inverted_icmp_vector_preds(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c, <2 x i32> %d) {
#0:
%cmp1 = icmp ne <2 x i32> %a, %b
%sel1 = select <2 x i1> %cmp1, <2 x i32> %c, <2 x i32> { 0, 0 }
%cmp2 = icmp eq <2 x i32> %a, %b
%sel2 = select <2 x i1> %cmp2, <2 x i32> %d, <2 x i32> { 0, 0 }
%or = or <2 x i32> %sel1, %sel2
ret <2 x i32> %or
}
=>
define <2 x i32> @fold_inverted_icmp_vector_preds(<2 x i32> %a, <2 x i32> %b, <2 x i32> %c, <2 x i32> %d) {
#0:
%cmp1.not = icmp eq <2 x i32> %a, %b
%sel1 = select <2 x i1> %cmp1.not, <2 x i32> { 0, 0 }, <2 x i32> %c
%cmp2 = icmp eq <2 x i32> %a, %b
%sel2 = select <2 x i1> %cmp2, <2 x i32> %d, <2 x i32> { 0, 0 }
%or = or <2 x i32> %sel1, %sel2
ret <2 x i32> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass
----------------------------------------
define i32 @par(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.1.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.1.0, %c
%not = xor i32 %iftmp.1.0, 4294967295
%t2 = and i32 %not, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
Transformation seems to be correct! (syntactically equal)
-- 35. InstCombinePass
----------------------------------------
define i32 @par(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%iftmp.1.0 = select i1 %t0, i32 4294967295, i32 0
%t1 = and i32 %iftmp.1.0, %c
%not = xor i32 %iftmp.1.0, 4294967295
%t2 = and i32 %not, %d
%t3 = or i32 %t1, %t2
ret i32 %t3
}
=>
define i32 @par(i32 %a, i32 %b, i32 %c, i32 %d) {
#0:
%t0 = icmp slt i32 %a, %b
%t3 = select i1 %t0, i32 %c, i32 %d
ret i32 %t3
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap0(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 39. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap0(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap0(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap1(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 43. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap1(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap1(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap2(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 47. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap2(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap2(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap3(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 51. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap3(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %sia
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap3(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap4(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap4(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap4(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap5(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap5(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %bc2, %sib
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap5(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap6(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 63. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap6(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and1, %and2
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap6(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap7(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 67. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_swap7(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
=>
define <2 x i64> @bitcast_select_swap7(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%#1 = bitcast <2 x i64> %sia to <4 x i32>
%#2 = bitcast <2 x i64> %sib to <4 x i32>
%#3 = select <4 x i1> %cmp, <4 x i32> %#1, <4 x i32> %#2
%or = bitcast <4 x i32> %#3 to <2 x i64>
ret <2 x i64> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_multi_uses(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
#0:
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %a, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %b, %bc2
%or = or <2 x i64> %and2, %and1
%add = add <2 x i64> %and2, %bc2
%sub = sub <2 x i64> %or, %add
ret <2 x i64> %sub
}
Transformation seems to be correct! (syntactically equal)
-- 71. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_select_multi_uses(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
#0:
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %a, %bc1
%neg = xor <4 x i32> %sext, { 4294967295, 4294967295, 4294967295, 4294967295 }
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
%and2 = and <2 x i64> %b, %bc2
%or = or <2 x i64> %and2, %and1
%add = add <2 x i64> %and2, %bc2
%sub = sub <2 x i64> %or, %add
ret <2 x i64> %sub
}
=>
define <2 x i64> @bitcast_select_multi_uses(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
#0:
%sext = sext <4 x i1> %cmp to <4 x i32>
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
%and1 = and <2 x i64> %bc1, %a
%#1 = bitcast <4 x i32> %sext to <2 x i64>
%bc2 = xor <2 x i64> %#1, { -1, -1 }
%and2 = and <2 x i64> %bc2, %b
%or = or <2 x i64> %and2, %and1
%add = add <2 x i64> %and2, %bc2
%sub = sub <2 x i64> %or, %add
ret <2 x i64> %sub
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass
----------------------------------------
define i1 @bools(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 75. InstCombinePass
----------------------------------------
define i1 @bools(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
ret i1 %or
}
=>
define i1 @bools(i1 %a, i1 %b, i1 %c) {
#0:
%or = select i1 %c, i1 %b, i1 %a
ret i1 %or
}
Transformation seems to be correct!
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass
----------------------------------------
define i1 @bools_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
ret i1 %or
}
Transformation seems to be correct! (syntactically equal)
-- 79. InstCombinePass
----------------------------------------
define i1 @bools_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
ret i1 %or
}
=>
define i1 @bools_logical(i1 %a, i1 %b, i1 %c) {
#0:
%or = select i1 %c, i1 %b, i1 %a
ret i1 %or
}
Transformation seems to be correct!
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses1(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
%xor = xor i1 %or, %and1
ret i1 %xor
}
Transformation seems to be correct! (syntactically equal)
-- 83. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses1(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
%xor = xor i1 %or, %and1
ret i1 %xor
}
=>
define i1 @bools_multi_uses1(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%or = select i1 %c, i1 %b, i1 %a
%xor = xor i1 %or, %and1
ret i1 %xor
}
Transformation seems to be correct!
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses1_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
%xor = xor i1 %or, %and1
ret i1 %xor
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses1_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
%xor = xor i1 %or, %and1
ret i1 %xor
}
=>
define i1 @bools_multi_uses1_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%or = select i1 %c, i1 %b, i1 %a
%xor = xor i1 %or, %and1
ret i1 %xor
}
Transformation seems to be correct!
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses2(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
%add = add i1 %and1, %and2
%and3 = and i1 %or, %add
ret i1 %and3
}
Transformation seems to be correct! (syntactically equal)
-- 91. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses2(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = and i1 %not, %a
%and2 = and i1 %c, %b
%or = or i1 %and1, %and2
%add = add i1 %and1, %and2
%and3 = and i1 %or, %add
ret i1 %and3
}
=>
define i1 @bools_multi_uses2(i1 %a, i1 %b, i1 %c) {
#0:
%or = select i1 %c, i1 %b, i1 %a
ret i1 %or
}
Transformation seems to be correct!
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses2_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
%add = add i1 %and1, %and2
%and3 = select i1 %or, i1 %add, i1 0
ret i1 %and3
}
Transformation seems to be correct! (syntactically equal)
-- 95. InstCombinePass
----------------------------------------
define i1 @bools_multi_uses2_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %and1, i1 1, i1 %and2
%add = add i1 %and1, %and2
%and3 = select i1 %or, i1 %add, i1 0
ret i1 %and3
}
=>
define i1 @bools_multi_uses2_logical(i1 %a, i1 %b, i1 %c) {
#0:
%not = xor i1 %c, 1
%and1 = select i1 %not, i1 %a, i1 0
%and2 = select i1 %c, i1 %b, i1 0
%or = select i1 %c, i1 %b, i1 %a
%add = xor i1 %and1, %and2
%and3 = select i1 %or, i1 %add, i1 0
ret i1 %and3
}
Transformation seems to be correct!
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass
----------------------------------------
define <4 x i1> @vec_of_bools(<4 x i1> %a, <4 x i1> %b, <4 x i1> %c) {
#0:
%not = xor <4 x i1> %c, { 1, 1, 1, 1 }
%and1 = and <4 x i1> %not, %a
%and2 = and <4 x i1> %b, %c
%or = or <4 x i1> %and2, %and1
ret <4 x i1> %or
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstCombinePass
----------------------------------------
define <4 x i1> @vec_of_bools(<4 x i1> %a, <4 x i1> %b, <4 x i1> %c) {
#0:
%not = xor <4 x i1> %c, { 1, 1, 1, 1 }
%and1 = and <4 x i1> %not, %a
%and2 = and <4 x i1> %b, %c
%or = or <4 x i1> %and2, %and1
ret <4 x i1> %or
}
=>
define <4 x i1> @vec_of_bools(<4 x i1> %a, <4 x i1> %b, <4 x i1> %c) {
#0:
%or = select <4 x i1> %c, <4 x i1> %b, <4 x i1> %a
ret <4 x i1> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 1 x i1>
-- 102. InstCombinePass
ERROR: Unsupported type: <vscale x 1 x i1>
-- 103. InstCombinePass
ERROR: Unsupported type: <vscale x 1 x i1>
-- 104. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 1 x i1>
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstCombinePass
----------------------------------------
define i4 @vec_of_casted_bools(i4 %a, i4 %b, <4 x i1> %c) {
#0:
%not = xor <4 x i1> %c, { 1, 1, 1, 1 }
%bc1 = bitcast <4 x i1> %not to i4
%bc2 = bitcast <4 x i1> %c to i4
%and1 = and i4 %a, %bc1
%and2 = and i4 %bc2, %b
%or = or i4 %and1, %and2
ret i4 %or
}
Transformation seems to be correct! (syntactically equal)
-- 107. InstCombinePass
----------------------------------------
define i4 @vec_of_casted_bools(i4 %a, i4 %b, <4 x i1> %c) {
#0:
%not = xor <4 x i1> %c, { 1, 1, 1, 1 }
%bc1 = bitcast <4 x i1> %not to i4
%bc2 = bitcast <4 x i1> %c to i4
%and1 = and i4 %a, %bc1
%and2 = and i4 %bc2, %b
%or = or i4 %and1, %and2
ret i4 %or
}
=>
define i4 @vec_of_casted_bools(i4 %a, i4 %b, <4 x i1> %c) {
#0:
%#1 = bitcast i4 %b to <4 x i1>
%#2 = bitcast i4 %a to <4 x i1>
%#3 = select <4 x i1> %c, <4 x i1> %#1, <4 x i1> %#2
%or = bitcast <4 x i1> %#3 to i4
ret i4 %or
}
Transformation seems to be correct!
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 1 x i64>
-- 110. InstCombinePass
ERROR: Unsupported type: <vscale x 1 x i64>
-- 111. InstCombinePass
ERROR: Unsupported type: <vscale x 1 x i64>
-- 112. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 1 x i64>
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_consts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, 0, 0, 4294967295 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 4294967295, 0 }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_consts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, 0, 0, 4294967295 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 4294967295, 0 }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
=>
define <4 x i32> @vec_sel_consts(<4 x i32> %a, <4 x i32> %b) {
#0:
%or = shufflevector <4 x i32> %a, <4 x i32> %b, 0, 5, 6, 3
ret <4 x i32> %or
}
Transformation seems to be correct!
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass
----------------------------------------
define <3 x i129> @vec_sel_consts_weird(<3 x i129> %a, <3 x i129> %b) {
#0:
%and1 = and <3 x i129> %a, { 680564733841876926926749214863536422911, 0, 680564733841876926926749214863536422911 }
%and2 = and <3 x i129> %b, { 0, 680564733841876926926749214863536422911, 0 }
%or = or <3 x i129> %and2, %and1
ret <3 x i129> %or
}
Transformation seems to be correct! (syntactically equal)
-- 119. InstCombinePass
----------------------------------------
define <3 x i129> @vec_sel_consts_weird(<3 x i129> %a, <3 x i129> %b) {
#0:
%and1 = and <3 x i129> %a, { 680564733841876926926749214863536422911, 0, 680564733841876926926749214863536422911 }
%and2 = and <3 x i129> %b, { 0, 680564733841876926926749214863536422911, 0 }
%or = or <3 x i129> %and2, %and1
ret <3 x i129> %or
}
=>
define <3 x i129> @vec_sel_consts_weird(<3 x i129> %a, <3 x i129> %b) {
#0:
%or = shufflevector <3 x i129> %a, <3 x i129> %b, 0, 4, 2
ret <3 x i129> %or
}
Transformation seems to be correct!
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass
----------------------------------------
define <4 x i32> @vec_not_sel_consts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, 0, 0, 0 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 0, 4294967295 }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 123. InstCombinePass
----------------------------------------
define <4 x i32> @vec_not_sel_consts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, 0, 0, 0 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 0, 4294967295 }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass
----------------------------------------
define <4 x i32> @vec_not_sel_consts_undef_elts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, undef, 0, 0 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 0, undef }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 127. InstCombinePass
----------------------------------------
define <4 x i32> @vec_not_sel_consts_undef_elts(<4 x i32> %a, <4 x i32> %b) {
#0:
%and1 = and <4 x i32> %a, { 4294967295, undef, 0, 0 }
%and2 = and <4 x i32> %b, { 0, 4294967295, 0, undef }
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_xor(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%mask = sext <4 x i1> %c to <4 x i32>
%mask_flip1 = xor <4 x i32> %mask, { 4294967295, 0, 0, 0 }
%not_mask_flip1 = xor <4 x i32> %mask, { 0, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %not_mask_flip1, %a
%and2 = and <4 x i32> %mask_flip1, %b
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_xor(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%mask = sext <4 x i1> %c to <4 x i32>
%mask_flip1 = xor <4 x i32> %mask, { 4294967295, 0, 0, 0 }
%not_mask_flip1 = xor <4 x i32> %mask, { 0, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %not_mask_flip1, %a
%and2 = and <4 x i32> %mask_flip1, %b
%or = or <4 x i32> %and1, %and2
ret <4 x i32> %or
}
=>
define <4 x i32> @vec_sel_xor(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%#1 = xor <4 x i1> %c, { 0, 1, 1, 1 }
%or = select <4 x i1> %#1, <4 x i32> %a, <4 x i32> %b
ret <4 x i32> %or
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_xor_multi_use(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%mask = sext <4 x i1> %c to <4 x i32>
%mask_flip1 = xor <4 x i32> %mask, { 4294967295, 0, 0, 0 }
%not_mask_flip1 = xor <4 x i32> %mask, { 0, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %not_mask_flip1, %a
%and2 = and <4 x i32> %mask_flip1, %b
%or = or <4 x i32> %and1, %and2
%add = add <4 x i32> %or, %mask_flip1
ret <4 x i32> %add
}
Transformation seems to be correct! (syntactically equal)
-- 135. InstCombinePass
----------------------------------------
define <4 x i32> @vec_sel_xor_multi_use(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%mask = sext <4 x i1> %c to <4 x i32>
%mask_flip1 = xor <4 x i32> %mask, { 4294967295, 0, 0, 0 }
%not_mask_flip1 = xor <4 x i32> %mask, { 0, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %not_mask_flip1, %a
%and2 = and <4 x i32> %mask_flip1, %b
%or = or <4 x i32> %and1, %and2
%add = add <4 x i32> %or, %mask_flip1
ret <4 x i32> %add
}
=>
define <4 x i32> @vec_sel_xor_multi_use(<4 x i32> %a, <4 x i32> %b, <4 x i1> %c) {
#0:
%#1 = xor <4 x i1> %c, { 1, 0, 0, 0 }
%mask_flip1 = sext <4 x i1> %#1 to <4 x i32>
%#2 = xor <4 x i1> %c, { 0, 1, 1, 1 }
%or = select <4 x i1> %#2, <4 x i32> %a, <4 x i32> %b
%add = add <4 x i32> %or, %mask_flip1
ret <4 x i32> %add
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass
----------------------------------------
define i32 @allSignBits(i32 %cond, i32 %tval, i32 %fval) {
#0:
%bitmask = ashr i32 %cond, 31
%not_bitmask = xor i32 %bitmask, 4294967295
%a1 = and i32 %tval, %bitmask
%a2 = and i32 %not_bitmask, %fval
%sel = or i32 %a1, %a2
ret i32 %sel
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstCombinePass
----------------------------------------
define i32 @allSignBits(i32 %cond, i32 %tval, i32 %fval) {
#0:
%bitmask = ashr i32 %cond, 31
%not_bitmask = xor i32 %bitmask, 4294967295
%a1 = and i32 %tval, %bitmask
%a2 = and i32 %not_bitmask, %fval
%sel = or i32 %a1, %a2
ret i32 %sel
}
=>
define i32 @allSignBits(i32 %cond, i32 %tval, i32 %fval) {
#0:
%isneg1 = icmp slt i32 %cond, 0
%a1 = select i1 %isneg1, i32 %tval, i32 0
%isneg = icmp slt i32 %cond, 0
%a2 = select i1 %isneg, i32 0, i32 %fval
%sel = or i32 %a1, %a2
ret i32 %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass
----------------------------------------
define <4 x i8> @allSignBits_vec(<4 x i8> %cond, <4 x i8> %tval, <4 x i8> %fval) {
#0:
%bitmask = ashr <4 x i8> %cond, { 7, 7, 7, 7 }
%not_bitmask = xor <4 x i8> %bitmask, { 255, 255, 255, 255 }
%a1 = and <4 x i8> %tval, %bitmask
%a2 = and <4 x i8> %fval, %not_bitmask
%sel = or <4 x i8> %a2, %a1
ret <4 x i8> %sel
}
Transformation seems to be correct! (syntactically equal)
-- 143. InstCombinePass
----------------------------------------
define <4 x i8> @allSignBits_vec(<4 x i8> %cond, <4 x i8> %tval, <4 x i8> %fval) {
#0:
%bitmask = ashr <4 x i8> %cond, { 7, 7, 7, 7 }
%not_bitmask = xor <4 x i8> %bitmask, { 255, 255, 255, 255 }
%a1 = and <4 x i8> %tval, %bitmask
%a2 = and <4 x i8> %fval, %not_bitmask
%sel = or <4 x i8> %a2, %a1
ret <4 x i8> %sel
}
=>
define <4 x i8> @allSignBits_vec(<4 x i8> %cond, <4 x i8> %tval, <4 x i8> %fval) {
#0:
%isneg1 = icmp slt <4 x i8> %cond, { 0, 0, 0, 0 }
%a1 = select <4 x i1> %isneg1, <4 x i8> %tval, <4 x i8> { 0, 0, 0, 0 }
%isneg = icmp slt <4 x i8> %cond, { 0, 0, 0, 0 }
%a2 = select <4 x i1> %isneg, <4 x i8> { 0, 0, 0, 0 }, <4 x i8> %fval
%sel = or <4 x i8> %a2, %a1
ret <4 x i8> %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass
----------------------------------------
define <2 x i64> @fp_bitcast(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%bc1 = bitcast <2 x double> %a to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%bc2 = bitcast <2 x double> %b to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstCombinePass
----------------------------------------
define <2 x i64> @fp_bitcast(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
#0:
%sia = fptosi <2 x double> %a to <2 x i64>
%sib = fptosi <2 x double> %b to <2 x i64>
%bc1 = bitcast <2 x double> %a to <2 x i64>
%and1 = and <2 x i64> %sia, %bc1
%bc2 = bitcast <2 x double> %b to <2 x i64>
%and2 = and <2 x i64> %sib, %bc2
%or = or <2 x i64> %and2, %and1
ret <2 x i64> %or
}
Transformation seems to be correct! (syntactically equal)
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstCombinePass
----------------------------------------
define <4 x i32> @computesignbits_through_shuffles(<4 x float> %x, <4 x float> %y, <4 x float> %z) {
#0:
%cmp = fcmp ole <4 x float> %x, %y
%sext = sext <4 x i1> %cmp to <4 x i32>
%s1 = shufflevector <4 x i32> %sext, <4 x i32> undef, 0, 0, 1, 1
%s2 = shufflevector <4 x i32> %sext, <4 x i32> undef, 2, 2, 3, 3
%shuf_or1 = or <4 x i32> %s1, %s2
%s3 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 0, 0, 1, 1
%s4 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 2, 2, 3, 3
%shuf_or2 = or <4 x i32> %s3, %s4
%not_or2 = xor <4 x i32> %shuf_or2, { 4294967295, 4294967295, 4294967295, 4294967295 }
%xbc = bitcast <4 x float> %x to <4 x i32>
%zbc = bitcast <4 x float> %z to <4 x i32>
%and1 = and <4 x i32> %not_or2, %xbc
%and2 = and <4 x i32> %shuf_or2, %zbc
%sel = or <4 x i32> %and1, %and2
ret <4 x i32> %sel
}
Transformation seems to be correct! (syntactically equal)
-- 151. InstCombinePass
----------------------------------------
define <4 x i32> @computesignbits_through_shuffles(<4 x float> %x, <4 x float> %y, <4 x float> %z) {
#0:
%cmp = fcmp ole <4 x float> %x, %y
%sext = sext <4 x i1> %cmp to <4 x i32>
%s1 = shufflevector <4 x i32> %sext, <4 x i32> undef, 0, 0, 1, 1
%s2 = shufflevector <4 x i32> %sext, <4 x i32> undef, 2, 2, 3, 3
%shuf_or1 = or <4 x i32> %s1, %s2
%s3 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 0, 0, 1, 1
%s4 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 2, 2, 3, 3
%shuf_or2 = or <4 x i32> %s3, %s4
%not_or2 = xor <4 x i32> %shuf_or2, { 4294967295, 4294967295, 4294967295, 4294967295 }
%xbc = bitcast <4 x float> %x to <4 x i32>
%zbc = bitcast <4 x float> %z to <4 x i32>
%and1 = and <4 x i32> %not_or2, %xbc
%and2 = and <4 x i32> %shuf_or2, %zbc
%sel = or <4 x i32> %and1, %and2
ret <4 x i32> %sel
}
=>
define <4 x i32> @computesignbits_through_shuffles(<4 x float> %x, <4 x float> %y, <4 x float> %z) {
#0:
%cmp = fcmp ole <4 x float> %x, %y
%sext = sext <4 x i1> %cmp to <4 x i32>
%s1 = shufflevector <4 x i32> %sext, <4 x i32> undef, 0, 0, 1, 1
%s2 = shufflevector <4 x i32> %sext, <4 x i32> undef, 2, 2, 3, 3
%shuf_or1 = or <4 x i32> %s1, %s2
%s3 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 0, 0, 1, 1
%s4 = shufflevector <4 x i32> %shuf_or1, <4 x i32> undef, 2, 2, 3, 3
%shuf_or2 = or <4 x i32> %s3, %s4
%#1 = trunc <4 x i32> %shuf_or2 to <4 x i1>
%sel.v = select <4 x i1> %#1, <4 x float> %z, <4 x float> %x
%sel = bitcast <4 x float> %sel.v to <4 x i32>
ret <4 x i32> %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstCombinePass
----------------------------------------
define <4 x i32> @computesignbits_through_two_input_shuffle(<4 x i32> %x, <4 x i32> %y, <4 x i1> %cond1, <4 x i1> %cond2) {
#0:
%sext1 = sext <4 x i1> %cond1 to <4 x i32>
%sext2 = sext <4 x i1> %cond2 to <4 x i32>
%cond = shufflevector <4 x i32> %sext1, <4 x i32> %sext2, 0, 2, 4, 6
%notcond = xor <4 x i32> %cond, { 4294967295, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %notcond, %x
%and2 = and <4 x i32> %cond, %y
%sel = or <4 x i32> %and1, %and2
ret <4 x i32> %sel
}
Transformation seems to be correct! (syntactically equal)
-- 155. InstCombinePass
----------------------------------------
define <4 x i32> @computesignbits_through_two_input_shuffle(<4 x i32> %x, <4 x i32> %y, <4 x i1> %cond1, <4 x i1> %cond2) {
#0:
%sext1 = sext <4 x i1> %cond1 to <4 x i32>
%sext2 = sext <4 x i1> %cond2 to <4 x i32>
%cond = shufflevector <4 x i32> %sext1, <4 x i32> %sext2, 0, 2, 4, 6
%notcond = xor <4 x i32> %cond, { 4294967295, 4294967295, 4294967295, 4294967295 }
%and1 = and <4 x i32> %notcond, %x
%and2 = and <4 x i32> %cond, %y
%sel = or <4 x i32> %and1, %and2
ret <4 x i32> %sel
}
=>
define <4 x i32> @computesignbits_through_two_input_shuffle(<4 x i32> %x, <4 x i32> %y, <4 x i1> %cond1, <4 x i1> %cond2) {
#0:
%sext1 = sext <4 x i1> %cond1 to <4 x i32>
%sext2 = sext <4 x i1> %cond2 to <4 x i32>
%cond = shufflevector <4 x i32> %sext1, <4 x i32> %sext2, 0, 2, 4, 6
%#1 = trunc <4 x i32> %cond to <4 x i1>
%sel = select <4 x i1> %#1, <4 x i32> %y, <4 x i32> %x
ret <4 x i32> %sel
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_vec_cond(<16 x i1> %cond, <2 x i64> %c, <2 x i64> %d) {
#0:
%s = sext <16 x i1> %cond to <16 x i8>
%t9 = bitcast <16 x i8> %s to <2 x i64>
%nott9 = xor <2 x i64> %t9, { -1, -1 }
%t11 = and <2 x i64> %nott9, %c
%t12 = and <2 x i64> %t9, %d
%r = or <2 x i64> %t11, %t12
ret <2 x i64> %r
}
Transformation seems to be correct! (syntactically equal)
-- 159. InstCombinePass
----------------------------------------
define <2 x i64> @bitcast_vec_cond(<16 x i1> %cond, <2 x i64> %c, <2 x i64> %d) {
#0:
%s = sext <16 x i1> %cond to <16 x i8>
%t9 = bitcast <16 x i8> %s to <2 x i64>
%nott9 = xor <2 x i64> %t9, { -1, -1 }
%t11 = and <2 x i64> %nott9, %c
%t12 = and <2 x i64> %t9, %d
%r = or <2 x i64> %t11, %t12
ret <2 x i64> %r
}
=>
define <2 x i64> @bitcast_vec_cond(<16 x i1> %cond, <2 x i64> %c, <2 x i64> %d) {
#0:
%#1 = bitcast <2 x i64> %d to <16 x i8>
%#2 = bitcast <2 x i64> %c to <16 x i8>
%#3 = select <16 x i1> %cond, <16 x i8> %#1, <16 x i8> %#2
%r = bitcast <16 x i8> %#3 to <2 x i64>
ret <2 x i64> %r
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 2 x i64>
-- 162. InstCombinePass
ERROR: Unsupported type: <vscale x 2 x i64>
-- 163. InstCombinePass
ERROR: Unsupported type: <vscale x 2 x i64>
-- 164. PassManager<Function> : Skipping NOP
ERROR: Unsupported type: <vscale x 2 x i64>
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstCombinePass
----------------------------------------
define <8 x i3> @bitcast_vec_cond_commute1(<3 x i1> %cond, <8 x i3> %pc, <8 x i3> %d) {
#0:
%c = mul <8 x i3> %pc, %pc
%s = sext <3 x i1> %cond to <3 x i8>
%t9 = bitcast <3 x i8> %s to <8 x i3>
%nott9 = xor <8 x i3> %t9, { 7, 7, 7, 7, 7, 7, 7, 7 }
%t11 = and <8 x i3> %c, %nott9
%t12 = and <8 x i3> %t9, %d
%r = or <8 x i3> %t11, %t12
ret <8 x i3> %r
}
Transformation seems to be correct! (syntactically equal)
-- 167. InstCombinePass
----------------------------------------
define <8 x i3> @bitcast_vec_cond_commute1(<3 x i1> %cond, <8 x i3> %pc, <8 x i3> %d) {
#0:
%c = mul <8 x i3> %pc, %pc
%s = sext <3 x i1> %cond to <3 x i8>
%t9 = bitcast <3 x i8> %s to <8 x i3>
%nott9 = xor <8 x i3> %t9, { 7, 7, 7, 7, 7, 7, 7, 7 }
%t11 = and <8 x i3> %c, %nott9
%t12 = and <8 x i3> %t9, %d
%r = or <8 x i3> %t11, %t12
ret <8 x i3> %r
}
=>
define <8 x i3> @bitcast_vec_cond_commute1(<3 x i1> %cond, <8 x i3> %pc, <8 x i3> %d) {
#0:
%c = mul <8 x i3> %pc, %pc
%s = sext <3 x i1> %cond to <3 x i8>
%t9 = bitcast <3 x i8> %s to <8 x i3>
%nott9 = xor <8 x i3> %t9, { 7, 7, 7, 7, 7, 7, 7, 7 }
%t11 = and <8 x i3> %c, %nott9
%t12 = and <8 x i3> %t9, %d
%r = or disjoint <8 x i3> %t11, %t12
ret <8 x i3> %r
}
Transformation doesn't verify! (unsound)
ERROR: Target is more poisonous than source
Example:
<3 x i1> %cond = < #x0 (0), undef, #x0 (0) >
<8 x i3> %pc = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<8 x i3> %d = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), undef, #x0 (0), #x0 (0) >
Source:
<8 x i3> %c = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<3 x i8> %s = < #x00 (0), #x00 (0) [based on undef value], #x00 (0) >
<8 x i3> %t9 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0) >
<8 x i3> %nott9 = < #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1) >
<8 x i3> %t11 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<8 x i3> %t12 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0) >
<8 x i3> %r = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
Target:
<8 x i3> %c = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<3 x i8> %s = < #x00 (0), #x00 (0), #x00 (0) >
<8 x i3> %t9 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0) >
<8 x i3> %nott9 = < #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1), #x7 (7, -1) >
<8 x i3> %t11 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<8 x i3> %t12 = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
<8 x i3> %r = < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), poison, #x0 (0), #x0 (0) >
Source value: < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x1 (1), #x0 (0), #x0 (0) >
Target value: < #x0 (0), #x0 (0), #x0 (0), #x0 (0), #x0 (0), poison, #x0 (0), #x0 (0) >
Pass: InstCombinePass
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=instcombine' '-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_faxswfP3_te7H.bc"
------------------- SMT STATS -------------------
Num queries: 267
Num invalid: 0
Num skips: 0
Num trivial: 215 (44.6%)
Num timeout: 24 (9.0%)
Num errors: 0 (0.0%)
Num SAT: 188 (70.4%)
Num UNSAT: 55 (20.6%)
Alive2: Transform doesn't verify; aborting!
RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/logical-select.ll -passes=instcombine -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/logical-select.ll + /home/nlopes/alive2/build/opt-alive.sh -passes=instcombine -S + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/logical-select.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/logical-select.ll
NOTE: This test would pass if undef didn't exist!