Test source: git
Comments: LLVM PR44185
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstCombinePass
----------------------------------------
define i8 @t0(i8 %x) {
%0:
%t0 = sub i8 %x, 214
ret i8 %t0
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstCombinePass
----------------------------------------
define i8 @t0(i8 %x) {
%0:
%t0 = sub i8 %x, 214
ret i8 %t0
}
=>
define i8 @t0(i8 %x) {
%0:
%t0 = add i8 %x, 42
ret i8 %t0
}
Transformation seems to be correct!
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstCombinePass
----------------------------------------
define i8 @t1(i8 %x, i8 %y) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 7. InstCombinePass
----------------------------------------
define i8 @t1(i8 %x, i8 %y) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @t1(i8 %x, i8 %y) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = add i8 %x, %y
ret i8 %t1
}
Transformation seems to be correct!
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstCombinePass
----------------------------------------
define i8 @t2(i8 %x, i8 %y) {
%0:
%t0 = shl i8 214, %y
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 11. InstCombinePass
----------------------------------------
define i8 @t2(i8 %x, i8 %y) {
%0:
%t0 = shl i8 214, %y
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @t2(i8 %x, i8 %y) {
%0:
%t0.neg = shl i8 42, %y
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstCombinePass
----------------------------------------
define i8 @n2(i8 %x, i8 %y) {
%0:
%t0 = shl i8 214, %y
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 15. InstCombinePass
----------------------------------------
define i8 @n2(i8 %x, i8 %y) {
%0:
%t0 = shl i8 214, %y
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstCombinePass
----------------------------------------
define i8 @t3(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = shl i8 %t0, %y
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 19. InstCombinePass
----------------------------------------
define i8 @t3(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = shl i8 %t0, %y
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @t3(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1.neg = shl i8 %z, %y
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstCombinePass
----------------------------------------
define i8 @n3(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = shl i8 %t0, %y
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstCombinePass
----------------------------------------
define i8 @n3(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = shl i8 %t0, %y
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstCombinePass
----------------------------------------
define i8 @t4(i8 %x, i1 %y) {
%0:
%t0 = select i1 %y, i8 214, i8 44
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstCombinePass
----------------------------------------
define i8 @t4(i8 %x, i1 %y) {
%0:
%t0 = select i1 %y, i8 214, i8 44
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @t4(i8 %x, i1 %y) {
%0:
%t0.neg = select i1 %y, i8 42, i8 212
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstCombinePass
----------------------------------------
define i8 @select_of_constants_multi_use(i1 %b) {
%0:
%s = select i1 %b, i8 42, i8 254
call void @use8(i8 %s)
%n = sub i8 0, %s
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 31. InstCombinePass
----------------------------------------
define i8 @select_of_constants_multi_use(i1 %b) {
%0:
%s = select i1 %b, i8 42, i8 254
call void @use8(i8 %s)
%n = sub i8 0, %s
ret i8 %n
}
=>
define i8 @select_of_constants_multi_use(i1 %b) {
%0:
%s.neg = select i1 %b, i8 214, i8 2
%s = select i1 %b, i8 42, i8 254
call void @use8(i8 %s)
ret i8 %s.neg
}
Transformation seems to be correct!
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstCombinePass
----------------------------------------
define i32 @PR52261(i1 %b) {
%0:
%s = select i1 %b, i32 2, i32 4294967294
%n = sub nsw i32 0, %s
%a = and i32 %s, %n
ret i32 %a
}
Transformation seems to be correct! (syntactically equal)
-- 35. InstCombinePass
----------------------------------------
define i32 @PR52261(i1 %b) {
%0:
%s = select i1 %b, i32 2, i32 4294967294
%n = sub nsw i32 0, %s
%a = and i32 %s, %n
ret i32 %a
}
=>
define i32 @PR52261(i1 %b) {
%0:
ret i32 2
}
Transformation seems to be correct!
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstCombinePass
----------------------------------------
define i8 @n4(i8 %x, i1 %y) {
%0:
%t0 = select i1 %y, i8 214, i8 44
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 39. InstCombinePass
----------------------------------------
define i8 @n4(i8 %x, i1 %y) {
%0:
%t0 = select i1 %y, i8 214, i8 44
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstCombinePass
----------------------------------------
define i8 @n5(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = select i1 %y, i8 214, i8 %z
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 43. InstCombinePass
----------------------------------------
define i8 @n5(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = select i1 %y, i8 214, i8 %z
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstCombinePass
----------------------------------------
define i8 @t6(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = select i1 %y, i8 214, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 47. InstCombinePass
----------------------------------------
define i8 @t6(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1 = select i1 %y, i8 214, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @t6(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = sub i8 0, %z
call void @use8(i8 %t0)
%t1.neg = select i1 %y, i8 42, i8 %z
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstCombinePass
----------------------------------------
define i8 @t7(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = shl i8 1, %z
%t1 = select i1 %y, i8 0, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 51. InstCombinePass
----------------------------------------
define i8 @t7(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = shl i8 1, %z
%t1 = select i1 %y, i8 0, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @t7(i8 %x, i1 %y, i8 %z) {
%0:
%t0.neg = shl i8 255, %z
%t1.neg = select i1 %y, i8 0, i8 %t0.neg
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstCombinePass
----------------------------------------
define i8 @n8(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = shl i8 1, %z
call void @use8(i8 %t0)
%t1 = select i1 %y, i8 0, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstCombinePass
----------------------------------------
define i8 @n8(i8 %x, i1 %y, i8 %z) {
%0:
%t0 = shl i8 1, %z
call void @use8(i8 %t0)
%t1 = select i1 %y, i8 0, i8 %t0
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstCombinePass
----------------------------------------
define i8 @t9(i8 %x, i8 %y) {
%0:
%t0 = sub i8 %y, %x
%t1 = sub i8 0, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstCombinePass
----------------------------------------
define i8 @t9(i8 %x, i8 %y) {
%0:
%t0 = sub i8 %y, %x
%t1 = sub i8 0, %t0
ret i8 %t1
}
=>
define i8 @t9(i8 %x, i8 %y) {
%0:
%t0.neg = sub i8 %x, %y
ret i8 %t0.neg
}
Transformation seems to be correct!
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstCombinePass
----------------------------------------
define i8 @n10(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 %y, %x
call void @use8(i8 %t0)
%t1 = sub i8 0, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 63. InstCombinePass
----------------------------------------
define i8 @n10(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 %y, %x
call void @use8(i8 %t0)
%t1 = sub i8 0, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstCombinePass
----------------------------------------
define i8 @neg_of_sub_from_constant(i8 %x) {
%0:
%s = sub i8 42, %x
%r = sub i8 0, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 67. InstCombinePass
----------------------------------------
define i8 @neg_of_sub_from_constant(i8 %x) {
%0:
%s = sub i8 42, %x
%r = sub i8 0, %s
ret i8 %r
}
=>
define i8 @neg_of_sub_from_constant(i8 %x) {
%0:
%s.neg = add i8 %x, 214
ret i8 %s.neg
}
Transformation seems to be correct!
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstCombinePass
----------------------------------------
define i8 @neg_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 0, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 71. InstCombinePass
----------------------------------------
define i8 @neg_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 0, %s
ret i8 %r
}
=>
define i8 @neg_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s.neg = add i8 %x, 214
%s = sub i8 42, %x
call void @use8(i8 %s)
ret i8 %s.neg
}
Transformation seems to be correct!
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_sub_from_constant(i8 %x) {
%0:
%s = sub i8 42, %x
%r = sub i8 11, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 75. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_sub_from_constant(i8 %x) {
%0:
%s = sub i8 42, %x
%r = sub i8 11, %s
ret i8 %r
}
=>
define i8 @sub_from_constant_of_sub_from_constant(i8 %x) {
%0:
%r = add i8 %x, 225
ret i8 %r
}
Transformation seems to be correct!
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 11, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 79. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 11, %s
ret i8 %r
}
=>
define i8 @sub_from_constant_of_sub_from_constant_multi_use(i8 %x) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = add i8 %x, 225
ret i8 %r
}
Transformation seems to be correct!
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_sub_from_constant(i8 %x, i8 %y) {
%0:
%s = sub i8 42, %x
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 83. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_sub_from_constant(i8 %x, i8 %y) {
%0:
%s = sub i8 42, %x
%r = sub i8 %y, %s
ret i8 %r
}
=>
define i8 @sub_from_variable_of_sub_from_constant(i8 %x, i8 %y) {
%0:
%s.neg = add i8 %x, 214
%r = add i8 %s.neg, %y
ret i8 %r
}
Transformation seems to be correct!
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_sub_from_constant_multi_use(i8 %x, i8 %y) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_sub_from_constant_multi_use(i8 %x, i8 %y) {
%0:
%s = sub i8 42, %x
call void @use8(i8 %s)
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstCombinePass
----------------------------------------
define i8 @t12(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%t2 = add i8 %t0, %t1
%t3 = sub i8 %x, %t2
ret i8 %t3
}
Transformation seems to be correct! (syntactically equal)
-- 91. InstCombinePass
----------------------------------------
define i8 @t12(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%t2 = add i8 %t0, %t1
%t3 = sub i8 %x, %t2
ret i8 %t3
}
=>
define i8 @t12(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%1 = add i8 %y, %z
%t3 = add i8 %1, %x
ret i8 %t3
}
Transformation seems to be correct!
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstCombinePass
----------------------------------------
define i8 @n13(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = add i8 %t0, %z
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 95. InstCombinePass
----------------------------------------
define i8 @n13(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = add i8 %t0, %z
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @n13(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1.neg = sub i8 %y, %z
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstCombinePass
----------------------------------------
define i8 @n14(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%t2 = add i8 %t0, %t1
call void @use8(i8 %t2)
%t3 = sub i8 %x, %t2
ret i8 %t3
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstCombinePass
----------------------------------------
define i8 @n14(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%t2 = add i8 %t0, %t1
call void @use8(i8 %t2)
%t3 = sub i8 %x, %t2
ret i8 %t3
}
=>
define i8 @n14(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = sub i8 0, %z
call void @use8(i8 %t1)
%1 = add i8 %y, %z
%t2 = sub i8 0, %1
call void @use8(i8 %t2)
%t3 = add i8 %1, %x
ret i8 %t3
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstCombinePass
----------------------------------------
define i8 @neg_of_add_with_constant(i8 %x) {
%0:
%s = add i8 %x, 42
%r = sub i8 0, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 103. InstCombinePass
----------------------------------------
define i8 @neg_of_add_with_constant(i8 %x) {
%0:
%s = add i8 %x, 42
%r = sub i8 0, %s
ret i8 %r
}
=>
define i8 @neg_of_add_with_constant(i8 %x) {
%0:
%r = sub i8 214, %x
ret i8 %r
}
Transformation seems to be correct!
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstCombinePass
----------------------------------------
define i8 @neg_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 0, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 107. InstCombinePass
----------------------------------------
define i8 @neg_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 0, %s
ret i8 %r
}
=>
define i8 @neg_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 214, %x
ret i8 %r
}
Transformation seems to be correct!
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_add_with_constant(i8 %x) {
%0:
%s = add i8 %x, 42
%r = sub i8 11, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_add_with_constant(i8 %x) {
%0:
%s = add i8 %x, 42
%r = sub i8 11, %s
ret i8 %r
}
=>
define i8 @sub_from_constant_of_add_with_constant(i8 %x) {
%0:
%r = sub i8 225, %x
ret i8 %r
}
Transformation seems to be correct!
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 11, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstCombinePass
----------------------------------------
define i8 @sub_from_constant_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 11, %s
ret i8 %r
}
=>
define i8 @sub_from_constant_of_add_with_constant_multi_use(i8 %x) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 225, %x
ret i8 %r
}
Transformation seems to be correct!
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_add_with_constant(i8 %x, i8 %y) {
%0:
%s = add i8 %x, 42
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 119. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_add_with_constant(i8 %x, i8 %y) {
%0:
%s = add i8 %x, 42
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_add_with_constant_multi_use(i8 %x, i8 %y) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 123. InstCombinePass
----------------------------------------
define i8 @sub_from_variable_of_add_with_constant_multi_use(i8 %x, i8 %y) {
%0:
%s = add i8 %x, 42
call void @use8(i8 %s)
%r = sub i8 %y, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstCombinePass
----------------------------------------
define i8 @t15(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = mul i8 %t0, %z
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 127. InstCombinePass
----------------------------------------
define i8 @t15(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = mul i8 %t0, %z
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @t15(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1.neg = mul i8 %y, %z
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstCombinePass
----------------------------------------
define i8 @n16(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = mul i8 %t0, %z
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstCombinePass
----------------------------------------
define i8 @n16(i8 %x, i8 %y, i8 %z) {
%0:
%t0 = sub i8 0, %y
call void @use8(i8 %t0)
%t1 = mul i8 %t0, %z
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstCombinePass
----------------------------------------
define i8 @t16(i1 %c, i8 %x) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%y = sub i8 0, %x
br label %end
%end:
%z = phi i8 [ %y, %then ], [ 214, %else ]
%n = sub i8 0, %z
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 135. InstCombinePass
----------------------------------------
define i8 @t16(i1 %c, i8 %x) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%y = sub i8 0, %x
br label %end
%end:
%z = phi i8 [ %y, %then ], [ 214, %else ]
%n = sub i8 0, %z
ret i8 %n
}
=>
define i8 @t16(i1 %c, i8 %x) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
br label %end
%end:
%z.neg = phi i8 [ %x, %then ], [ 42, %else ]
ret i8 %z.neg
}
Transformation seems to be correct!
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstCombinePass
----------------------------------------
define i8 @n17(i1 %c, i8 %x) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%y = sub i8 0, %x
br label %end
%end:
%z = phi i8 [ %y, %then ], [ 214, %else ]
call void @use8(i8 %z)
%n = sub i8 0, %z
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstCombinePass
----------------------------------------
define i8 @n17(i1 %c, i8 %x) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%y = sub i8 0, %x
br label %end
%end:
%z = phi i8 [ %y, %then ], [ 214, %else ]
call void @use8(i8 %z)
%n = sub i8 0, %z
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstCombinePass
----------------------------------------
define i8 @n19(i1 %c, i8 %x, i8 %y) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%z = sub i8 0, %x
br label %end
%end:
%r = phi i8 [ %z, %then ], [ %y, %else ]
%n = sub i8 0, %r
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 143. InstCombinePass
----------------------------------------
define i8 @n19(i1 %c, i8 %x, i8 %y) {
%begin:
br i1 %c, label %then, label %else
%else:
br label %end
%then:
%z = sub i8 0, %x
br label %end
%end:
%r = phi i8 [ %z, %then ], [ %y, %else ]
%n = sub i8 0, %r
ret i8 %n
}
Transformation seems to be correct! (syntactically equal)
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstCombinePass
----------------------------------------
define void @phi_with_duplicate_incoming_basic_blocks(i32 %x, i32 %y, i1 %should_lookup, i32 %z) {
%entry:
%x_inc = add i32 %x, 1
br i1 %should_lookup, label %lookup, label %loop
%lookup:
%to_lookup = phi i32 [ %y, %entry ], [ %negated_metaval, %loop ]
switch i32 %to_lookup, label %end [
i32 0, label %loop
i32 42, label %loop
]
%loop:
%metaval = phi i32 [ %x_inc, %lookup ], [ %x_inc, %lookup ], [ 84, %entry ]
%negated_metaval = sub i32 0, %metaval
%repeat = call i1 @use32gen1(i32 %negated_metaval)
br i1 %repeat, label %lookup, label %end
%end:
ret void
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstCombinePass
----------------------------------------
define void @phi_with_duplicate_incoming_basic_blocks(i32 %x, i32 %y, i1 %should_lookup, i32 %z) {
%entry:
%x_inc = add i32 %x, 1
br i1 %should_lookup, label %lookup, label %loop
%lookup:
%to_lookup = phi i32 [ %y, %entry ], [ %negated_metaval, %loop ]
switch i32 %to_lookup, label %end [
i32 0, label %loop
i32 42, label %loop
]
%loop:
%metaval = phi i32 [ %x_inc, %lookup ], [ %x_inc, %lookup ], [ 84, %entry ]
%negated_metaval = sub i32 0, %metaval
%repeat = call i1 @use32gen1(i32 %negated_metaval)
br i1 %repeat, label %lookup, label %end
%end:
ret void
}
=>
define void @phi_with_duplicate_incoming_basic_blocks(i32 %x, i32 %y, i1 %should_lookup, i32 %z) {
%entry:
%x_inc.neg = xor i32 %x, 4294967295
br i1 %should_lookup, label %lookup, label %loop
%lookup:
%to_lookup = phi i32 [ %y, %entry ], [ %metaval.neg, %loop ]
switch i32 %to_lookup, label %end [
i32 0, label %loop
i32 42, label %loop
]
%loop:
%metaval.neg = phi i32 [ %x_inc.neg, %lookup ], [ %x_inc.neg, %lookup ], [ 4294967212, %entry ]
%repeat = call i1 @use32gen1(i32 %metaval.neg)
br i1 %repeat, label %lookup, label %end
%end:
ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstCombinePass
----------------------------------------
define i8 @t20(i8 %x, i16 %y) {
%0:
%t0 = shl i16 65494, %y
%t1 = trunc i16 %t0 to i8
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 151. InstCombinePass
----------------------------------------
define i8 @t20(i8 %x, i16 %y) {
%0:
%t0 = shl i16 65494, %y
%t1 = trunc i16 %t0 to i8
%t2 = sub i8 %x, %t1
ret i8 %t2
}
=>
define i8 @t20(i8 %x, i16 %y) {
%0:
%t0.neg = shl i16 42, %y
%t1.neg = trunc i16 %t0.neg to i8
%t2 = add i8 %t1.neg, %x
ret i8 %t2
}
Transformation seems to be correct!
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstCombinePass
----------------------------------------
define i8 @n21(i8 %x, i16 %y) {
%0:
%t0 = shl i16 65494, %y
%t1 = trunc i16 %t0 to i8
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 155. InstCombinePass
----------------------------------------
define i8 @n21(i8 %x, i16 %y) {
%0:
%t0 = shl i16 65494, %y
%t1 = trunc i16 %t0 to i8
call void @use8(i8 %t1)
%t2 = sub i8 %x, %t1
ret i8 %t2
}
Transformation seems to be correct! (syntactically equal)
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstCombinePass
----------------------------------------
define i4 @negate_xor(i4 %x) {
%0:
%o = xor i4 %x, 5
%r = sub i4 0, %o
ret i4 %r
}
Transformation seems to be correct! (syntactically equal)
-- 159. InstCombinePass
----------------------------------------
define i4 @negate_xor(i4 %x) {
%0:
%o = xor i4 %x, 5
%r = sub i4 0, %o
ret i4 %r
}
=>
define i4 @negate_xor(i4 %x) {
%0:
%1 = xor i4 %x, 10
%o.neg = add i4 %1, 1
ret i4 %o.neg
}
Transformation seems to be correct!
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstCombinePass
----------------------------------------
define <2 x i4> @negate_xor_vec(<2 x i4> %x) {
%0:
%o = xor <2 x i4> %x, { 5, 10 }
%r = sub <2 x i4> { 0, 0 }, %o
ret <2 x i4> %r
}
Transformation seems to be correct! (syntactically equal)
-- 163. InstCombinePass
----------------------------------------
define <2 x i4> @negate_xor_vec(<2 x i4> %x) {
%0:
%o = xor <2 x i4> %x, { 5, 10 }
%r = sub <2 x i4> { 0, 0 }, %o
ret <2 x i4> %r
}
=>
define <2 x i4> @negate_xor_vec(<2 x i4> %x) {
%0:
%1 = xor <2 x i4> %x, { 10, 5 }
%o.neg = add <2 x i4> %1, { 1, 1 }
ret <2 x i4> %o.neg
}
Transformation seems to be correct!
-- 164. PassManager<Function> : Skipping NOP
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstCombinePass
----------------------------------------
define i8 @negate_xor_use(i8 %x) {
%0:
%o = xor i8 %x, 5
call void @use8(i8 %o)
%r = sub i8 0, %o
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 167. InstCombinePass
----------------------------------------
define i8 @negate_xor_use(i8 %x) {
%0:
%o = xor i8 %x, 5
call void @use8(i8 %o)
%r = sub i8 0, %o
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstCombinePass
----------------------------------------
define i4 @negate_shl_xor(i4 %x, i4 %y) {
%0:
%o = xor i4 %x, 5
%s = shl i4 %o, %y
%r = sub i4 0, %s
ret i4 %r
}
Transformation seems to be correct! (syntactically equal)
-- 171. InstCombinePass
----------------------------------------
define i4 @negate_shl_xor(i4 %x, i4 %y) {
%0:
%o = xor i4 %x, 5
%s = shl i4 %o, %y
%r = sub i4 0, %s
ret i4 %r
}
=>
define i4 @negate_shl_xor(i4 %x, i4 %y) {
%0:
%1 = xor i4 %x, 10
%o.neg = add i4 %1, 1
%s.neg = shl i4 %o.neg, %y
ret i4 %s.neg
}
Transformation seems to be correct!
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstCombinePass
----------------------------------------
define i8 @negate_shl_not_uses(i8 %x, i8 %y) {
%0:
%o = xor i8 %x, 255
call void @use8(i8 %o)
%s = shl i8 %o, %y
%r = sub i8 0, %s
ret i8 %r
}
Transformation seems to be correct! (syntactically equal)
-- 175. InstCombinePass
----------------------------------------
define i8 @negate_shl_not_uses(i8 %x, i8 %y) {
%0:
%o = xor i8 %x, 255
call void @use8(i8 %o)
%s = shl i8 %o, %y
%r = sub i8 0, %s
ret i8 %r
}
=>
define i8 @negate_shl_not_uses(i8 %x, i8 %y) {
%0:
%o.neg = add i8 %x, 1
%o = xor i8 %x, 255
call void @use8(i8 %o)
%s.neg = shl i8 %o.neg, %y
ret i8 %s.neg
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstCombinePass
----------------------------------------
define <2 x i4> @negate_mul_not_uses_vec(<2 x i4> %x, <2 x i4> %y) {
%0:
%o = xor <2 x i4> %x, { 15, 15 }
call void @use_v2i4(<2 x i4> %o)
%s = mul <2 x i4> %o, %y
%r = sub <2 x i4> { 0, 0 }, %s
ret <2 x i4> %r
}
Transformation seems to be correct! (syntactically equal)
-- 179. InstCombinePass
----------------------------------------
define <2 x i4> @negate_mul_not_uses_vec(<2 x i4> %x, <2 x i4> %y) {
%0:
%o = xor <2 x i4> %x, { 15, 15 }
call void @use_v2i4(<2 x i4> %o)
%s = mul <2 x i4> %o, %y
%r = sub <2 x i4> { 0, 0 }, %s
ret <2 x i4> %r
}
=>
define <2 x i4> @negate_mul_not_uses_vec(<2 x i4> %x, <2 x i4> %y) {
%0:
%o.neg = add <2 x i4> %x, { 1, 1 }
%o = xor <2 x i4> %x, { 15, 15 }
call void @use_v2i4(<2 x i4> %o)
%s.neg = mul <2 x i4> %o.neg, %y
ret <2 x i4> %s.neg
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstCombinePass
----------------------------------------
define i8 @negate_sdiv(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 183. InstCombinePass
----------------------------------------
define i8 @negate_sdiv(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @negate_sdiv(i8 %x, i8 %y) {
%0:
%t0.neg = sdiv i8 %y, 214
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstCombinePass
----------------------------------------
define i8 @negate_sdiv_extrause(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 187. InstCombinePass
----------------------------------------
define i8 @negate_sdiv_extrause(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstCombinePass
----------------------------------------
define i8 @negate_sdiv_extrause2(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
call void @use8(i8 %t0)
%t1 = sub i8 0, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 191. InstCombinePass
----------------------------------------
define i8 @negate_sdiv_extrause2(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
call void @use8(i8 %t0)
%t1 = sub i8 0, %t0
ret i8 %t1
}
=>
define i8 @negate_sdiv_extrause2(i8 %x, i8 %y) {
%0:
%t0 = sdiv i8 %y, 42
call void @use8(i8 %t0)
%t1 = sub nsw i8 0, %t0
ret i8 %t1
}
Transformation seems to be correct!
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstCombinePass
----------------------------------------
define i8 @negate_ashr(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 7
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 195. InstCombinePass
----------------------------------------
define i8 @negate_ashr(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 7
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @negate_ashr(i8 %x, i8 %y) {
%0:
%t0.neg = lshr i8 %y, 7
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 196. PassManager<Function> : Skipping NOP
-- 197. PassManager<Function> : Skipping NOP
-- 198. InstCombinePass
----------------------------------------
define i8 @negate_lshr(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 7
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 199. InstCombinePass
----------------------------------------
define i8 @negate_lshr(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 7
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @negate_lshr(i8 %x, i8 %y) {
%0:
%t0.neg = ashr i8 %y, 7
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstCombinePass
----------------------------------------
define i8 @negate_ashr_extrause(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 7
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 203. InstCombinePass
----------------------------------------
define i8 @negate_ashr_extrause(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 7
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InstCombinePass
----------------------------------------
define i8 @negate_lshr_extrause(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 7
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 207. InstCombinePass
----------------------------------------
define i8 @negate_lshr_extrause(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 7
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstCombinePass
----------------------------------------
define i8 @negate_ashr_wrongshift(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 6
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 211. InstCombinePass
----------------------------------------
define i8 @negate_ashr_wrongshift(i8 %x, i8 %y) {
%0:
%t0 = ashr i8 %y, 6
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 212. PassManager<Function> : Skipping NOP
-- 213. PassManager<Function> : Skipping NOP
-- 214. InstCombinePass
----------------------------------------
define i8 @negate_lshr_wrongshift(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 6
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 215. InstCombinePass
----------------------------------------
define i8 @negate_lshr_wrongshift(i8 %x, i8 %y) {
%0:
%t0 = lshr i8 %y, 6
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 216. PassManager<Function> : Skipping NOP
-- 217. PassManager<Function> : Skipping NOP
-- 218. InstCombinePass
----------------------------------------
define i8 @negate_sext(i8 %x, i1 %y) {
%0:
%t0 = sext i1 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 219. InstCombinePass
----------------------------------------
define i8 @negate_sext(i8 %x, i1 %y) {
%0:
%t0 = sext i1 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @negate_sext(i8 %x, i1 %y) {
%0:
%t0.neg = zext i1 %y to i8
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 220. PassManager<Function> : Skipping NOP
-- 221. PassManager<Function> : Skipping NOP
-- 222. InstCombinePass
----------------------------------------
define i8 @negate_zext(i8 %x, i1 %y) {
%0:
%t0 = zext i1 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 223. InstCombinePass
----------------------------------------
define i8 @negate_zext(i8 %x, i1 %y) {
%0:
%t0 = zext i1 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
=>
define i8 @negate_zext(i8 %x, i1 %y) {
%0:
%t0.neg = sext i1 %y to i8
%t1 = add i8 %t0.neg, %x
ret i8 %t1
}
Transformation seems to be correct!
-- 224. PassManager<Function> : Skipping NOP
-- 225. PassManager<Function> : Skipping NOP
-- 226. InstCombinePass
----------------------------------------
define i8 @negate_sext_extrause(i8 %x, i1 %y) {
%0:
%t0 = sext i1 %y to i8
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 227. InstCombinePass
----------------------------------------
define i8 @negate_sext_extrause(i8 %x, i1 %y) {
%0:
%t0 = sext i1 %y to i8
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 228. PassManager<Function> : Skipping NOP
-- 229. PassManager<Function> : Skipping NOP
-- 230. InstCombinePass
----------------------------------------
define i8 @negate_zext_extrause(i8 %x, i1 %y) {
%0:
%t0 = zext i1 %y to i8
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 231. InstCombinePass
----------------------------------------
define i8 @negate_zext_extrause(i8 %x, i1 %y) {
%0:
%t0 = zext i1 %y to i8
call void @use8(i8 %t0)
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 232. PassManager<Function> : Skipping NOP
-- 233. PassManager<Function> : Skipping NOP
-- 234. InstCombinePass
----------------------------------------
define i8 @negate_sext_wrongwidth(i8 %x, i2 %y) {
%0:
%t0 = sext i2 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 235. InstCombinePass
----------------------------------------
define i8 @negate_sext_wrongwidth(i8 %x, i2 %y) {
%0:
%t0 = sext i2 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 236. PassManager<Function> : Skipping NOP
-- 237. PassManager<Function> : Skipping NOP
-- 238. InstCombinePass
----------------------------------------
define i8 @negate_zext_wrongwidth(i8 %x, i2 %y) {
%0:
%t0 = zext i2 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 239. InstCombinePass
----------------------------------------
define i8 @negate_zext_wrongwidth(i8 %x, i2 %y) {
%0:
%t0 = zext i2 %y to i8
%t1 = sub i8 %x, %t0
ret i8 %t1
}
Transformation seems to be correct! (syntactically equal)
-- 240. PassManager<Function> : Skipping NOP
-- 241. PassManager<Function> : Skipping NOP
-- 242. InstCombinePass
----------------------------------------
define <2 x i4> @negate_shufflevector_oneinput_reverse(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0 = shl <2 x i4> { 10, 5 }, %x
%t1 = shufflevector <2 x i4> %t0, <2 x i4> undef, 1, 0
%t2 = sub <2 x i4> %y, %t1
ret <2 x i4> %t2
}
Transformation seems to be correct! (syntactically equal)
-- 243. InstCombinePass
----------------------------------------
define <2 x i4> @negate_shufflevector_oneinput_reverse(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0 = shl <2 x i4> { 10, 5 }, %x
%t1 = shufflevector <2 x i4> %t0, <2 x i4> undef, 1, 0
%t2 = sub <2 x i4> %y, %t1
ret <2 x i4> %t2
}
=>
define <2 x i4> @negate_shufflevector_oneinput_reverse(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0.neg = shl <2 x i4> { 6, 11 }, %x
%t1.neg = shufflevector <2 x i4> %t0.neg, <2 x i4> undef, 1, 0
%t2 = add <2 x i4> %t1.neg, %y
ret <2 x i4> %t2
}
Transformation seems to be correct!
-- 244. PassManager<Function> : Skipping NOP
-- 245. PassManager<Function> : Skipping NOP
-- 246. InstCombinePass
----------------------------------------
define <2 x i4> @negate_shufflevector_oneinput_second_lane_is_undef(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0 = shl <2 x i4> { 10, 5 }, %x
%t1 = shufflevector <2 x i4> %t0, <2 x i4> undef, 0, 2
%t2 = sub <2 x i4> %y, %t1
ret <2 x i4> %t2
}
Transformation seems to be correct! (syntactically equal)
-- 247. InstCombinePass
----------------------------------------
define <2 x i4> @negate_shufflevector_oneinput_second_lane_is_undef(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0 = shl <2 x i4> { 10, 5 }, %x
%t1 = shufflevector <2 x i4> %t0, <2 x i4> undef, 0, 2
%t2 = sub <2 x i4> %y, %t1
ret <2 x i4> %t2
}
=>
define <2 x i4> @negate_shufflevector_oneinput_second_lane_is_undef(<2 x i4> %x, <2 x i4> %y) {
%0:
%t0.neg = shl <2 x i4> { 6, 11 }, %x
%t1.neg = shufflevector <2 x i4> %t0.neg, <2 x i4> undef, 0, 4294967295
%t2 = add <2 x i4> %t1.neg, %y
ret <2 x i4> %t2
}
Transformation doesn't verify! (unsound)
ERROR: Target is more poisonous than source
Example:
<2 x i4> %x = < poison, poison >
<2 x i4> %y = < poison, #x0 (0) [based on undef value] >
Source:
<2 x i4> %t0 = < poison, poison >
<2 x i4> %t1 = < poison, #x0 (0) [based on undef value] >
<2 x i4> %t2 = < poison, #x0 (0) >
Target:
<2 x i4> %t0.neg = < poison, poison >
<2 x i4> %t1.neg = < poison, poison >
<2 x i4> %t2 = < poison, poison >
Source value: < poison, #x0 (0) >
Target value: < poison, poison >
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'
------------------- SMT STATS -------------------
Num queries: 237
Num invalid: 0
Num skips: 0
Num trivial: 100 (29.7%)
Num timeout: 4 (1.7%)
Num errors: 0 (0.0%)
Num SAT: 123 (51.9%)
Num UNSAT: 110 (46.4%)
Alive2: Transform doesn't verify; aborting!
+ : 'RUN: at line 2' + /home/nlopes/alive2/build/opt-alive.sh -passes=instcombine -S + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/sub-of-negatible.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/sub-of-negatible.ll