Test source: git
Source: <stdin>
-- 1. ModuleToFunctionPassAdaptor
-- 1. PassManager<Function> : Skipping NOP
-- 2. InstSimplifyPass
----------------------------------------
define i1 @tautological_ule(i8 %x) {
#0:
%cmp = icmp ule i8 %x, 255
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 3. InstSimplifyPass
----------------------------------------
define i1 @tautological_ule(i8 %x) {
#0:
%cmp = icmp ule i8 %x, 255
ret i1 %cmp
}
=>
define i1 @tautological_ule(i8 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 4. PassManager<Function> : Skipping NOP
-- 5. PassManager<Function> : Skipping NOP
-- 6. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ule_vec(<2 x i8> %x) {
#0:
%cmp = icmp ule <2 x i8> %x, { 255, 255 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 7. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ule_vec(<2 x i8> %x) {
#0:
%cmp = icmp ule <2 x i8> %x, { 255, 255 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @tautological_ule_vec(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 8. PassManager<Function> : Skipping NOP
-- 9. PassManager<Function> : Skipping NOP
-- 10. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ule_vec_partial_undef(<2 x i8> %x) {
#0:
%cmp = icmp ule <2 x i8> %x, { 255, undef }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 11. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ule_vec_partial_undef(<2 x i8> %x) {
#0:
%cmp = icmp ule <2 x i8> %x, { 255, undef }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @tautological_ule_vec_partial_undef(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. InstSimplifyPass
----------------------------------------
define i1 @tautological_ugt(i8 %x) {
#0:
%cmp = icmp ugt i8 %x, 255
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 15. InstSimplifyPass
----------------------------------------
define i1 @tautological_ugt(i8 %x) {
#0:
%cmp = icmp ugt i8 %x, 255
ret i1 %cmp
}
=>
define i1 @tautological_ugt(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 16. PassManager<Function> : Skipping NOP
-- 17. PassManager<Function> : Skipping NOP
-- 18. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ugt_vec(<2 x i8> %x) {
#0:
%cmp = icmp ugt <2 x i8> %x, { 255, 255 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 19. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ugt_vec(<2 x i8> %x) {
#0:
%cmp = icmp ugt <2 x i8> %x, { 255, 255 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @tautological_ugt_vec(<2 x i8> %x) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 20. PassManager<Function> : Skipping NOP
-- 21. PassManager<Function> : Skipping NOP
-- 22. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ugt_vec_partial_undef(<2 x i8> %x) {
#0:
%cmp = icmp ugt <2 x i8> %x, { undef, 255 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 23. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological_ugt_vec_partial_undef(<2 x i8> %x) {
#0:
%cmp = icmp ugt <2 x i8> %x, { undef, 255 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @tautological_ugt_vec_partial_undef(<2 x i8> %x) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. InstSimplifyPass
----------------------------------------
define i1 @urem3(i32 %X) {
#0:
%A = urem i32 %X, 10
%B = icmp ult i32 %A, 15
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 27. InstSimplifyPass
----------------------------------------
define i1 @urem3(i32 %X) {
#0:
%A = urem i32 %X, 10
%B = icmp ult i32 %A, 15
ret i1 %B
}
=>
define i1 @urem3(i32 %X) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 28. PassManager<Function> : Skipping NOP
-- 29. PassManager<Function> : Skipping NOP
-- 30. InstSimplifyPass
----------------------------------------
define <2 x i1> @urem3_vec(<2 x i32> %X) {
#0:
%A = urem <2 x i32> %X, { 10, 10 }
%B = icmp ult <2 x i32> %A, { 15, 15 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 31. InstSimplifyPass
----------------------------------------
define <2 x i1> @urem3_vec(<2 x i32> %X) {
#0:
%A = urem <2 x i32> %X, { 10, 10 }
%B = icmp ult <2 x i32> %A, { 15, 15 }
ret <2 x i1> %B
}
=>
define <2 x i1> @urem3_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 32. PassManager<Function> : Skipping NOP
-- 33. PassManager<Function> : Skipping NOP
-- 34. InstSimplifyPass
----------------------------------------
define <2 x i1> @urem3_vec_partial_undef(<2 x i32> %X) {
#0:
%A = urem <2 x i32> %X, { 10, 10 }
%B = icmp ult <2 x i32> %A, { undef, 15 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 35. InstSimplifyPass
----------------------------------------
define <2 x i1> @urem3_vec_partial_undef(<2 x i32> %X) {
#0:
%A = urem <2 x i32> %X, { 10, 10 }
%B = icmp ult <2 x i32> %A, { undef, 15 }
ret <2 x i1> %B
}
=>
define <2 x i1> @urem3_vec_partial_undef(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. InstSimplifyPass
----------------------------------------
define i1 @srem1(i32 %X) {
#0:
%A = srem i32 %X, 4294967291
%B = icmp sgt i32 %A, 5
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 39. InstSimplifyPass
----------------------------------------
define i1 @srem1(i32 %X) {
#0:
%A = srem i32 %X, 4294967291
%B = icmp sgt i32 %A, 5
ret i1 %B
}
=>
define i1 @srem1(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 40. PassManager<Function> : Skipping NOP
-- 41. PassManager<Function> : Skipping NOP
-- 42. InstSimplifyPass
----------------------------------------
define <2 x i1> @srem1_vec(<2 x i32> %X) {
#0:
%A = srem <2 x i32> %X, { 4294967291, 4294967291 }
%B = icmp sgt <2 x i32> %A, { 5, 5 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 43. InstSimplifyPass
----------------------------------------
define <2 x i1> @srem1_vec(<2 x i32> %X) {
#0:
%A = srem <2 x i32> %X, { 4294967291, 4294967291 }
%B = icmp sgt <2 x i32> %A, { 5, 5 }
ret <2 x i1> %B
}
=>
define <2 x i1> @srem1_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 44. PassManager<Function> : Skipping NOP
-- 45. PassManager<Function> : Skipping NOP
-- 46. InstSimplifyPass
----------------------------------------
define <2 x i1> @srem1_vec_partial_undef(<2 x i32> %X) {
#0:
%A = srem <2 x i32> %X, { 4294967291, 4294967291 }
%B = icmp sgt <2 x i32> %A, { 5, undef }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 47. InstSimplifyPass
----------------------------------------
define <2 x i1> @srem1_vec_partial_undef(<2 x i32> %X) {
#0:
%A = srem <2 x i32> %X, { 4294967291, 4294967291 }
%B = icmp sgt <2 x i32> %A, { 5, undef }
ret <2 x i1> %B
}
=>
define <2 x i1> @srem1_vec_partial_undef(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. InstSimplifyPass
----------------------------------------
define i1 @udiv5(i32 %X) {
#0:
%A = udiv i32 123, %X
%C = icmp ugt i32 %A, 124
ret i1 %C
}
Transformation seems to be correct! (syntactically equal)
-- 51. InstSimplifyPass
----------------------------------------
define i1 @udiv5(i32 %X) {
#0:
%A = udiv i32 123, %X
%C = icmp ugt i32 %A, 124
ret i1 %C
}
=>
define i1 @udiv5(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 52. PassManager<Function> : Skipping NOP
-- 53. PassManager<Function> : Skipping NOP
-- 54. InstSimplifyPass
----------------------------------------
define <2 x i1> @udiv5_vec(<2 x i32> %X) {
#0:
%A = udiv <2 x i32> { 123, 123 }, %X
%C = icmp ugt <2 x i32> %A, { 124, 124 }
ret <2 x i1> %C
}
Transformation seems to be correct! (syntactically equal)
-- 55. InstSimplifyPass
----------------------------------------
define <2 x i1> @udiv5_vec(<2 x i32> %X) {
#0:
%A = udiv <2 x i32> { 123, 123 }, %X
%C = icmp ugt <2 x i32> %A, { 124, 124 }
ret <2 x i1> %C
}
=>
define <2 x i1> @udiv5_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 56. PassManager<Function> : Skipping NOP
-- 57. PassManager<Function> : Skipping NOP
-- 58. InstSimplifyPass
----------------------------------------
define i1 @udiv1(i32 %X) {
#0:
%A = udiv i32 %X, 1000000
%B = icmp ult i32 %A, 5000
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 59. InstSimplifyPass
----------------------------------------
define i1 @udiv1(i32 %X) {
#0:
%A = udiv i32 %X, 1000000
%B = icmp ult i32 %A, 5000
ret i1 %B
}
=>
define i1 @udiv1(i32 %X) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. InstSimplifyPass
----------------------------------------
define <2 x i1> @udiv1_vec(<2 x i32> %X) {
#0:
%A = udiv <2 x i32> %X, { 1000000, 1000000 }
%B = icmp ult <2 x i32> %A, { 5000, 5000 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 63. InstSimplifyPass
----------------------------------------
define <2 x i1> @udiv1_vec(<2 x i32> %X) {
#0:
%A = udiv <2 x i32> %X, { 1000000, 1000000 }
%B = icmp ult <2 x i32> %A, { 5000, 5000 }
ret <2 x i1> %B
}
=>
define <2 x i1> @udiv1_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 64. PassManager<Function> : Skipping NOP
-- 65. PassManager<Function> : Skipping NOP
-- 66. InstSimplifyPass
----------------------------------------
define i1 @compare_dividend(i32 %a) {
#0:
%div = sdiv i32 2, %a
%cmp = icmp eq i32 %div, 3
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 67. InstSimplifyPass
----------------------------------------
define i1 @compare_dividend(i32 %a) {
#0:
%div = sdiv i32 2, %a
%cmp = icmp eq i32 %div, 3
ret i1 %cmp
}
=>
define i1 @compare_dividend(i32 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 68. PassManager<Function> : Skipping NOP
-- 69. PassManager<Function> : Skipping NOP
-- 70. InstSimplifyPass
----------------------------------------
define <2 x i1> @compare_dividend_vec(<2 x i32> %a) {
#0:
%div = sdiv <2 x i32> { 2, 2 }, %a
%cmp = icmp eq <2 x i32> %div, { 3, 3 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 71. InstSimplifyPass
----------------------------------------
define <2 x i1> @compare_dividend_vec(<2 x i32> %a) {
#0:
%div = sdiv <2 x i32> { 2, 2 }, %a
%cmp = icmp eq <2 x i32> %div, { 3, 3 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @compare_dividend_vec(<2 x i32> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. InstSimplifyPass
----------------------------------------
define i1 @sdiv1(i32 %X) {
#0:
%A = sdiv i32 %X, 1000000
%B = icmp slt i32 %A, 3000
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 75. InstSimplifyPass
----------------------------------------
define i1 @sdiv1(i32 %X) {
#0:
%A = sdiv i32 %X, 1000000
%B = icmp slt i32 %A, 3000
ret i1 %B
}
=>
define i1 @sdiv1(i32 %X) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 76. PassManager<Function> : Skipping NOP
-- 77. PassManager<Function> : Skipping NOP
-- 78. InstSimplifyPass
----------------------------------------
define <2 x i1> @sdiv1_vec(<2 x i32> %X) {
#0:
%A = sdiv <2 x i32> %X, { 1000000, 1000000 }
%B = icmp slt <2 x i32> %A, { 3000, 3000 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 79. InstSimplifyPass
----------------------------------------
define <2 x i1> @sdiv1_vec(<2 x i32> %X) {
#0:
%A = sdiv <2 x i32> %X, { 1000000, 1000000 }
%B = icmp slt <2 x i32> %A, { 3000, 3000 }
ret <2 x i1> %B
}
=>
define <2 x i1> @sdiv1_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 80. PassManager<Function> : Skipping NOP
-- 81. PassManager<Function> : Skipping NOP
-- 82. InstSimplifyPass
----------------------------------------
define i1 @shl5(i32 %X) {
#0:
%sub = shl nuw i32 4, %X
%cmp = icmp ugt i32 %sub, 3
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 83. InstSimplifyPass
----------------------------------------
define i1 @shl5(i32 %X) {
#0:
%sub = shl nuw i32 4, %X
%cmp = icmp ugt i32 %sub, 3
ret i1 %cmp
}
=>
define i1 @shl5(i32 %X) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 84. PassManager<Function> : Skipping NOP
-- 85. PassManager<Function> : Skipping NOP
-- 86. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl5_vec(<2 x i32> %X) {
#0:
%sub = shl nuw <2 x i32> { 4, 4 }, %X
%cmp = icmp ugt <2 x i32> %sub, { 3, 3 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 87. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl5_vec(<2 x i32> %X) {
#0:
%sub = shl nuw <2 x i32> { 4, 4 }, %X
%cmp = icmp ugt <2 x i32> %sub, { 3, 3 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @shl5_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 88. PassManager<Function> : Skipping NOP
-- 89. PassManager<Function> : Skipping NOP
-- 90. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl5_vec_partial_undef(<2 x i32> %X) {
#0:
%sub = shl nuw <2 x i32> { 4, 4 }, %X
%cmp = icmp ugt <2 x i32> %sub, { undef, 3 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 91. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl5_vec_partial_undef(<2 x i32> %X) {
#0:
%sub = shl nuw <2 x i32> { 4, 4 }, %X
%cmp = icmp ugt <2 x i32> %sub, { undef, 3 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @shl5_vec_partial_undef(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. InstSimplifyPass
----------------------------------------
define i1 @shl2(i32 %X) {
#0:
%sub = shl nsw i32 4294967295, %X
%cmp = icmp eq i32 %sub, 31
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 95. InstSimplifyPass
----------------------------------------
define i1 @shl2(i32 %X) {
#0:
%sub = shl nsw i32 4294967295, %X
%cmp = icmp eq i32 %sub, 31
ret i1 %cmp
}
=>
define i1 @shl2(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 96. PassManager<Function> : Skipping NOP
-- 97. PassManager<Function> : Skipping NOP
-- 98. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl2_vec(<2 x i32> %X) {
#0:
%sub = shl nsw <2 x i32> { 4294967295, 4294967295 }, %X
%cmp = icmp eq <2 x i32> %sub, { 31, 31 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 99. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl2_vec(<2 x i32> %X) {
#0:
%sub = shl nsw <2 x i32> { 4294967295, 4294967295 }, %X
%cmp = icmp eq <2 x i32> %sub, { 31, 31 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @shl2_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. InstSimplifyPass
----------------------------------------
define i1 @shl4(i32 %X) {
#0:
%sub = shl nsw i32 4294967295, %X
%cmp = icmp sle i32 %sub, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 103. InstSimplifyPass
----------------------------------------
define i1 @shl4(i32 %X) {
#0:
%sub = shl nsw i32 4294967295, %X
%cmp = icmp sle i32 %sub, 4294967295
ret i1 %cmp
}
=>
define i1 @shl4(i32 %X) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 104. PassManager<Function> : Skipping NOP
-- 105. PassManager<Function> : Skipping NOP
-- 106. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl4_vec(<2 x i32> %X) {
#0:
%sub = shl nsw <2 x i32> { 4294967295, 4294967295 }, %X
%cmp = icmp sle <2 x i32> %sub, { 4294967295, 4294967295 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 107. InstSimplifyPass
----------------------------------------
define <2 x i1> @shl4_vec(<2 x i32> %X) {
#0:
%sub = shl nsw <2 x i32> { 4294967295, 4294967295 }, %X
%cmp = icmp sle <2 x i32> %sub, { 4294967295, 4294967295 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @shl4_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. InstSimplifyPass
----------------------------------------
define i1 @icmp_shl_nsw_1(i64 %a) {
#0:
%shl = shl nsw i64 1, %a
%cmp = icmp sge i64 %shl, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 111. InstSimplifyPass
----------------------------------------
define i1 @icmp_shl_nsw_1(i64 %a) {
#0:
%shl = shl nsw i64 1, %a
%cmp = icmp sge i64 %shl, 0
ret i1 %cmp
}
=>
define i1 @icmp_shl_nsw_1(i64 %a) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 112. PassManager<Function> : Skipping NOP
-- 113. PassManager<Function> : Skipping NOP
-- 114. InstSimplifyPass
----------------------------------------
define <2 x i1> @icmp_shl_nsw_1_vec(<2 x i64> %a) {
#0:
%shl = shl nsw <2 x i64> { 1, 1 }, %a
%cmp = icmp sge <2 x i64> %shl, { 0, 0 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 115. InstSimplifyPass
----------------------------------------
define <2 x i1> @icmp_shl_nsw_1_vec(<2 x i64> %a) {
#0:
%shl = shl nsw <2 x i64> { 1, 1 }, %a
%cmp = icmp sge <2 x i64> %shl, { 0, 0 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @icmp_shl_nsw_1_vec(<2 x i64> %a) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. InstSimplifyPass
----------------------------------------
define i1 @icmp_shl_nsw_neg1(i64 %a) {
#0:
%shl = shl nsw i64 -1, %a
%cmp = icmp sge i64 %shl, 3
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 119. InstSimplifyPass
----------------------------------------
define i1 @icmp_shl_nsw_neg1(i64 %a) {
#0:
%shl = shl nsw i64 -1, %a
%cmp = icmp sge i64 %shl, 3
ret i1 %cmp
}
=>
define i1 @icmp_shl_nsw_neg1(i64 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 120. PassManager<Function> : Skipping NOP
-- 121. PassManager<Function> : Skipping NOP
-- 122. InstSimplifyPass
----------------------------------------
define <2 x i1> @icmp_shl_nsw_neg1_vec(<2 x i64> %a) {
#0:
%shl = shl nsw <2 x i64> { -1, -1 }, %a
%cmp = icmp sge <2 x i64> %shl, { 3, 3 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 123. InstSimplifyPass
----------------------------------------
define <2 x i1> @icmp_shl_nsw_neg1_vec(<2 x i64> %a) {
#0:
%shl = shl nsw <2 x i64> { -1, -1 }, %a
%cmp = icmp sge <2 x i64> %shl, { 3, 3 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @icmp_shl_nsw_neg1_vec(<2 x i64> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. InstSimplifyPass
----------------------------------------
define i1 @lshr2(i32 %x) {
#0:
%s = lshr i32 %x, 30
%c = icmp ugt i32 %s, 8
ret i1 %c
}
Transformation seems to be correct! (syntactically equal)
-- 127. InstSimplifyPass
----------------------------------------
define i1 @lshr2(i32 %x) {
#0:
%s = lshr i32 %x, 30
%c = icmp ugt i32 %s, 8
ret i1 %c
}
=>
define i1 @lshr2(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 128. PassManager<Function> : Skipping NOP
-- 129. PassManager<Function> : Skipping NOP
-- 130. InstSimplifyPass
----------------------------------------
define <2 x i1> @lshr2_vec(<2 x i32> %x) {
#0:
%s = lshr <2 x i32> %x, { 30, 30 }
%c = icmp ugt <2 x i32> %s, { 8, 8 }
ret <2 x i1> %c
}
Transformation seems to be correct! (syntactically equal)
-- 131. InstSimplifyPass
----------------------------------------
define <2 x i1> @lshr2_vec(<2 x i32> %x) {
#0:
%s = lshr <2 x i32> %x, { 30, 30 }
%c = icmp ugt <2 x i32> %s, { 8, 8 }
ret <2 x i1> %c
}
=>
define <2 x i1> @lshr2_vec(<2 x i32> %x) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. InstSimplifyPass
----------------------------------------
define i1 @exact_lshr_ugt_false(i32 %a) {
#0:
%shr = lshr exact i32 30, %a
%cmp = icmp ult i32 %shr, 15
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 135. InstSimplifyPass
----------------------------------------
define i1 @exact_lshr_ugt_false(i32 %a) {
#0:
%shr = lshr exact i32 30, %a
%cmp = icmp ult i32 %shr, 15
ret i1 %cmp
}
=>
define i1 @exact_lshr_ugt_false(i32 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 136. PassManager<Function> : Skipping NOP
-- 137. PassManager<Function> : Skipping NOP
-- 138. InstSimplifyPass
----------------------------------------
define <2 x i1> @exact_lshr_ugt_false_vec(<2 x i32> %a) {
#0:
%shr = lshr exact <2 x i32> { 30, 30 }, %a
%cmp = icmp ult <2 x i32> %shr, { 15, 15 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 139. InstSimplifyPass
----------------------------------------
define <2 x i1> @exact_lshr_ugt_false_vec(<2 x i32> %a) {
#0:
%shr = lshr exact <2 x i32> { 30, 30 }, %a
%cmp = icmp ult <2 x i32> %shr, { 15, 15 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @exact_lshr_ugt_false_vec(<2 x i32> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 140. PassManager<Function> : Skipping NOP
-- 141. PassManager<Function> : Skipping NOP
-- 142. InstSimplifyPass
----------------------------------------
define i1 @lshr_sgt_false(i32 %a) {
#0:
%shr = lshr i32 1, %a
%cmp = icmp sgt i32 %shr, 1
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 143. InstSimplifyPass
----------------------------------------
define i1 @lshr_sgt_false(i32 %a) {
#0:
%shr = lshr i32 1, %a
%cmp = icmp sgt i32 %shr, 1
ret i1 %cmp
}
=>
define i1 @lshr_sgt_false(i32 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 144. PassManager<Function> : Skipping NOP
-- 145. PassManager<Function> : Skipping NOP
-- 146. InstSimplifyPass
----------------------------------------
define <2 x i1> @lshr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = lshr <2 x i32> { 1, 1 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 1, 1 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 147. InstSimplifyPass
----------------------------------------
define <2 x i1> @lshr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = lshr <2 x i32> { 1, 1 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 1, 1 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @lshr_sgt_false_vec(<2 x i32> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 148. PassManager<Function> : Skipping NOP
-- 149. PassManager<Function> : Skipping NOP
-- 150. InstSimplifyPass
----------------------------------------
define i1 @ashr2(i32 %x) {
#0:
%s = ashr i32 %x, 30
%c = icmp slt i32 %s, 4294967291
ret i1 %c
}
Transformation seems to be correct! (syntactically equal)
-- 151. InstSimplifyPass
----------------------------------------
define i1 @ashr2(i32 %x) {
#0:
%s = ashr i32 %x, 30
%c = icmp slt i32 %s, 4294967291
ret i1 %c
}
=>
define i1 @ashr2(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 152. PassManager<Function> : Skipping NOP
-- 153. PassManager<Function> : Skipping NOP
-- 154. InstSimplifyPass
----------------------------------------
define <2 x i1> @ashr2_vec(<2 x i32> %x) {
#0:
%s = ashr <2 x i32> %x, { 30, 30 }
%c = icmp slt <2 x i32> %s, { 4294967291, 4294967291 }
ret <2 x i1> %c
}
Transformation seems to be correct! (syntactically equal)
-- 155. InstSimplifyPass
----------------------------------------
define <2 x i1> @ashr2_vec(<2 x i32> %x) {
#0:
%s = ashr <2 x i32> %x, { 30, 30 }
%c = icmp slt <2 x i32> %s, { 4294967291, 4294967291 }
ret <2 x i1> %c
}
=>
define <2 x i1> @ashr2_vec(<2 x i32> %x) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 156. PassManager<Function> : Skipping NOP
-- 157. PassManager<Function> : Skipping NOP
-- 158. InstSimplifyPass
----------------------------------------
define i1 @ashr_sgt_false(i32 %a) {
#0:
%shr = ashr i32 4294967266, %a
%cmp = icmp sgt i32 %shr, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 159. InstSimplifyPass
----------------------------------------
define i1 @ashr_sgt_false(i32 %a) {
#0:
%shr = ashr i32 4294967266, %a
%cmp = icmp sgt i32 %shr, 4294967295
ret i1 %cmp
}
=>
define i1 @ashr_sgt_false(i32 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 160. PassManager<Function> : Skipping NOP
-- 161. PassManager<Function> : Skipping NOP
-- 162. InstSimplifyPass
----------------------------------------
define <2 x i1> @ashr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = ashr <2 x i32> { 4294967266, 4294967266 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 4294967295, 4294967295 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 163. InstSimplifyPass
----------------------------------------
define <2 x i1> @ashr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = ashr <2 x i32> { 4294967266, 4294967266 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 4294967295, 4294967295 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @ashr_sgt_false_vec(<2 x i32> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 164. PassManager<Function> : Skipping NOP
-- 165. PassManager<Function> : Skipping NOP
-- 166. InstSimplifyPass
----------------------------------------
define i1 @exact_ashr_sgt_false(i32 %a) {
#0:
%shr = ashr exact i32 4294967266, %a
%cmp = icmp sgt i32 %shr, 4294967281
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 167. InstSimplifyPass
----------------------------------------
define i1 @exact_ashr_sgt_false(i32 %a) {
#0:
%shr = ashr exact i32 4294967266, %a
%cmp = icmp sgt i32 %shr, 4294967281
ret i1 %cmp
}
=>
define i1 @exact_ashr_sgt_false(i32 %a) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 168. PassManager<Function> : Skipping NOP
-- 169. PassManager<Function> : Skipping NOP
-- 170. InstSimplifyPass
----------------------------------------
define <2 x i1> @exact_ashr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = ashr exact <2 x i32> { 4294967266, 4294967266 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 4294967281, 4294967281 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 171. InstSimplifyPass
----------------------------------------
define <2 x i1> @exact_ashr_sgt_false_vec(<2 x i32> %a) {
#0:
%shr = ashr exact <2 x i32> { 4294967266, 4294967266 }, %a
%cmp = icmp sgt <2 x i32> %shr, { 4294967281, 4294967281 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @exact_ashr_sgt_false_vec(<2 x i32> %a) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 172. PassManager<Function> : Skipping NOP
-- 173. PassManager<Function> : Skipping NOP
-- 174. InstSimplifyPass
----------------------------------------
define i1 @or1(i32 %X) {
#0:
%A = or i32 %X, 62
%B = icmp ult i32 %A, 50
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 175. InstSimplifyPass
----------------------------------------
define i1 @or1(i32 %X) {
#0:
%A = or i32 %X, 62
%B = icmp ult i32 %A, 50
ret i1 %B
}
=>
define i1 @or1(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 176. PassManager<Function> : Skipping NOP
-- 177. PassManager<Function> : Skipping NOP
-- 178. InstSimplifyPass
----------------------------------------
define <2 x i1> @or1_vec(<2 x i32> %X) {
#0:
%A = or <2 x i32> %X, { 62, 62 }
%B = icmp ult <2 x i32> %A, { 50, 50 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 179. InstSimplifyPass
----------------------------------------
define <2 x i1> @or1_vec(<2 x i32> %X) {
#0:
%A = or <2 x i32> %X, { 62, 62 }
%B = icmp ult <2 x i32> %A, { 50, 50 }
ret <2 x i1> %B
}
=>
define <2 x i1> @or1_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 180. PassManager<Function> : Skipping NOP
-- 181. PassManager<Function> : Skipping NOP
-- 182. InstSimplifyPass
----------------------------------------
define <2 x i1> @or1_vec_partial_undef(<2 x i32> %X) {
#0:
%A = or <2 x i32> %X, { 62, 62 }
%B = icmp ult <2 x i32> %A, { undef, 50 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 183. InstSimplifyPass
----------------------------------------
define <2 x i1> @or1_vec_partial_undef(<2 x i32> %X) {
#0:
%A = or <2 x i32> %X, { 62, 62 }
%B = icmp ult <2 x i32> %A, { undef, 50 }
ret <2 x i1> %B
}
=>
define <2 x i1> @or1_vec_partial_undef(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 184. PassManager<Function> : Skipping NOP
-- 185. PassManager<Function> : Skipping NOP
-- 186. InstSimplifyPass
----------------------------------------
define i1 @or2_true(i8 %x) {
#0:
%y = or i8 %x, 64
%z = icmp sge i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 187. InstSimplifyPass
----------------------------------------
define i1 @or2_true(i8 %x) {
#0:
%y = or i8 %x, 64
%z = icmp sge i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 188. PassManager<Function> : Skipping NOP
-- 189. PassManager<Function> : Skipping NOP
-- 190. InstSimplifyPass
----------------------------------------
define i1 @or2_unknown(i8 %x) {
#0:
%y = or i8 %x, 64
%z = icmp sgt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 191. InstSimplifyPass
----------------------------------------
define i1 @or2_unknown(i8 %x) {
#0:
%y = or i8 %x, 64
%z = icmp sgt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 192. PassManager<Function> : Skipping NOP
-- 193. PassManager<Function> : Skipping NOP
-- 194. InstSimplifyPass
----------------------------------------
define i1 @or3_true(i8 %x) {
#0:
%y = or i8 %x, 78
%z = icmp sge i8 %y, 206
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 195. InstSimplifyPass
----------------------------------------
define i1 @or3_true(i8 %x) {
#0:
%y = or i8 %x, 78
%z = icmp sge i8 %y, 206
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 196. PassManager<Function> : Skipping NOP
-- 197. PassManager<Function> : Skipping NOP
-- 198. InstSimplifyPass
----------------------------------------
define i1 @or3_unknown(i8 %x) {
#0:
%y = or i8 %x, 78
%z = icmp sgt i8 %y, 206
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 199. InstSimplifyPass
----------------------------------------
define i1 @or3_unknown(i8 %x) {
#0:
%y = or i8 %x, 78
%z = icmp sgt i8 %y, 206
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 200. PassManager<Function> : Skipping NOP
-- 201. PassManager<Function> : Skipping NOP
-- 202. InstSimplifyPass
----------------------------------------
define i1 @or4_true(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp sge i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 203. InstSimplifyPass
----------------------------------------
define i1 @or4_true(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp sge i8 %y, 192
ret i1 %z
}
=>
define i1 @or4_true(i8 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 204. PassManager<Function> : Skipping NOP
-- 205. PassManager<Function> : Skipping NOP
-- 206. InstSimplifyPass
----------------------------------------
define i1 @or4_unknown(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp sgt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 207. InstSimplifyPass
----------------------------------------
define i1 @or4_unknown(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp sgt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 208. PassManager<Function> : Skipping NOP
-- 209. PassManager<Function> : Skipping NOP
-- 210. InstSimplifyPass
----------------------------------------
define i1 @or5_true(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp uge i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 211. InstSimplifyPass
----------------------------------------
define i1 @or5_true(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp uge i8 %y, 192
ret i1 %z
}
=>
define i1 @or5_true(i8 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 212. PassManager<Function> : Skipping NOP
-- 213. PassManager<Function> : Skipping NOP
-- 214. InstSimplifyPass
----------------------------------------
define i1 @or5_unknown(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp ugt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 215. InstSimplifyPass
----------------------------------------
define i1 @or5_unknown(i8 %x) {
#0:
%y = or i8 %x, 192
%z = icmp ugt i8 %y, 192
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 216. PassManager<Function> : Skipping NOP
-- 217. PassManager<Function> : Skipping NOP
-- 218. InstSimplifyPass
----------------------------------------
define i1 @and1(i32 %X) {
#0:
%A = and i32 %X, 62
%B = icmp ugt i32 %A, 70
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 219. InstSimplifyPass
----------------------------------------
define i1 @and1(i32 %X) {
#0:
%A = and i32 %X, 62
%B = icmp ugt i32 %A, 70
ret i1 %B
}
=>
define i1 @and1(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 220. PassManager<Function> : Skipping NOP
-- 221. PassManager<Function> : Skipping NOP
-- 222. InstSimplifyPass
----------------------------------------
define <2 x i1> @and1_vec(<2 x i32> %X) {
#0:
%A = and <2 x i32> %X, { 62, 62 }
%B = icmp ugt <2 x i32> %A, { 70, 70 }
ret <2 x i1> %B
}
Transformation seems to be correct! (syntactically equal)
-- 223. InstSimplifyPass
----------------------------------------
define <2 x i1> @and1_vec(<2 x i32> %X) {
#0:
%A = and <2 x i32> %X, { 62, 62 }
%B = icmp ugt <2 x i32> %A, { 70, 70 }
ret <2 x i1> %B
}
=>
define <2 x i1> @and1_vec(<2 x i32> %X) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 224. PassManager<Function> : Skipping NOP
-- 225. PassManager<Function> : Skipping NOP
-- 226. InstSimplifyPass
----------------------------------------
define i1 @and2(i32 %X) {
#0:
%A = and i32 %X, 62
%B = icmp sgt i32 %A, 70
ret i1 %B
}
Transformation seems to be correct! (syntactically equal)
-- 227. InstSimplifyPass
----------------------------------------
define i1 @and2(i32 %X) {
#0:
%A = and i32 %X, 62
%B = icmp sgt i32 %A, 70
ret i1 %B
}
=>
define i1 @and2(i32 %X) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 228. PassManager<Function> : Skipping NOP
-- 229. PassManager<Function> : Skipping NOP
-- 230. InstSimplifyPass
----------------------------------------
define i1 @and3_true1(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sge i8 %y, 181
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 231. InstSimplifyPass
----------------------------------------
define i1 @and3_true1(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sge i8 %y, 181
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 232. PassManager<Function> : Skipping NOP
-- 233. PassManager<Function> : Skipping NOP
-- 234. InstSimplifyPass
----------------------------------------
define i1 @and3_unknown1(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sgt i8 %y, 181
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 235. InstSimplifyPass
----------------------------------------
define i1 @and3_unknown1(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sgt i8 %y, 181
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 236. PassManager<Function> : Skipping NOP
-- 237. PassManager<Function> : Skipping NOP
-- 238. InstSimplifyPass
----------------------------------------
define i1 @and3_true2(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sle i8 %y, 53
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 239. InstSimplifyPass
----------------------------------------
define i1 @and3_true2(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp sle i8 %y, 53
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 240. PassManager<Function> : Skipping NOP
-- 241. PassManager<Function> : Skipping NOP
-- 242. InstSimplifyPass
----------------------------------------
define i1 @and3_unknown2(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp slt i8 %y, 53
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 243. InstSimplifyPass
----------------------------------------
define i1 @and3_unknown2(i8 %x) {
#0:
%y = and i8 %x, 181
%z = icmp slt i8 %y, 53
ret i1 %z
}
Transformation seems to be correct! (syntactically equal)
-- 244. PassManager<Function> : Skipping NOP
-- 245. PassManager<Function> : Skipping NOP
-- 246. InstSimplifyPass
----------------------------------------
define i1 @tautological9(i32 %x) {
#0:
%add = add nuw i32 %x, 13
%cmp = icmp ne i32 %add, 12
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 247. InstSimplifyPass
----------------------------------------
define i1 @tautological9(i32 %x) {
#0:
%add = add nuw i32 %x, 13
%cmp = icmp ne i32 %add, 12
ret i1 %cmp
}
=>
define i1 @tautological9(i32 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 248. PassManager<Function> : Skipping NOP
-- 249. PassManager<Function> : Skipping NOP
-- 250. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological9_vec(<2 x i32> %x) {
#0:
%add = add nuw <2 x i32> %x, { 13, 13 }
%cmp = icmp ne <2 x i32> %add, { 12, 12 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 251. InstSimplifyPass
----------------------------------------
define <2 x i1> @tautological9_vec(<2 x i32> %x) {
#0:
%add = add nuw <2 x i32> %x, { 13, 13 }
%cmp = icmp ne <2 x i32> %add, { 12, 12 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @tautological9_vec(<2 x i32> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 252. PassManager<Function> : Skipping NOP
-- 253. PassManager<Function> : Skipping NOP
-- 254. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const1(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483649
%cmp = icmp sgt i32 %add, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 255. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const1(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483649
%cmp = icmp sgt i32 %add, 0
ret i1 %cmp
}
=>
define i1 @add_nsw_neg_const1(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 256. PassManager<Function> : Skipping NOP
-- 257. PassManager<Function> : Skipping NOP
-- 258. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_sgt(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 259. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_sgt(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
=>
define i1 @add_nsw_sgt(i8 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 260. PassManager<Function> : Skipping NOP
-- 261. PassManager<Function> : Skipping NOP
-- 262. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_nuw_sgt(i8 %x) {
#0:
%add = add nsw nuw i8 %x, 5
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 263. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_nuw_sgt(i8 %x) {
#0:
%add = add nsw nuw i8 %x, 5
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
=>
define i1 @add_nsw_nuw_sgt(i8 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 264. PassManager<Function> : Skipping NOP
-- 265. PassManager<Function> : Skipping NOP
-- 266. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_sgt_limit(i8 %x) {
#0:
%add = add nsw i8 %x, 4
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 267. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_sgt_limit(i8 %x) {
#0:
%add = add nsw i8 %x, 4
%cmp = icmp sgt i8 %add, 132
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 268. PassManager<Function> : Skipping NOP
-- 269. PassManager<Function> : Skipping NOP
-- 270. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_slt(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp slt i8 %add, 133
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 271. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_slt(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp slt i8 %add, 133
ret i1 %cmp
}
=>
define i1 @add_nsw_slt(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 272. PassManager<Function> : Skipping NOP
-- 273. PassManager<Function> : Skipping NOP
-- 274. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_nuw_slt(i8 %x) {
#0:
%add = add nsw nuw i8 %x, 5
%cmp = icmp slt i8 %add, 133
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 275. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_nuw_slt(i8 %x) {
#0:
%add = add nsw nuw i8 %x, 5
%cmp = icmp slt i8 %add, 133
ret i1 %cmp
}
=>
define i1 @add_nsw_nuw_slt(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 276. PassManager<Function> : Skipping NOP
-- 277. PassManager<Function> : Skipping NOP
-- 278. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_slt_limit(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp slt i8 %add, 134
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 279. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_slt_limit(i8 %x) {
#0:
%add = add nsw i8 %x, 5
%cmp = icmp slt i8 %add, 134
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 280. PassManager<Function> : Skipping NOP
-- 281. PassManager<Function> : Skipping NOP
-- 282. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const2(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483649
%cmp = icmp sgt i32 %add, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 283. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const2(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483649
%cmp = icmp sgt i32 %add, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 284. PassManager<Function> : Skipping NOP
-- 285. PassManager<Function> : Skipping NOP
-- 286. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const3(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483650
%cmp = icmp sgt i32 %add, 1
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 287. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const3(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483650
%cmp = icmp sgt i32 %add, 1
ret i1 %cmp
}
=>
define i1 @add_nsw_neg_const3(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 288. PassManager<Function> : Skipping NOP
-- 289. PassManager<Function> : Skipping NOP
-- 290. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const4(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483650
%cmp = icmp sgt i32 %add, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 291. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const4(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483650
%cmp = icmp sgt i32 %add, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 292. PassManager<Function> : Skipping NOP
-- 293. PassManager<Function> : Skipping NOP
-- 294. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const5(i32 %x) {
#0:
%add = add nsw i32 %x, 4294967254
%cmp = icmp ne i32 %add, 2147483606
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 295. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const5(i32 %x) {
#0:
%add = add nsw i32 %x, 4294967254
%cmp = icmp ne i32 %add, 2147483606
ret i1 %cmp
}
=>
define i1 @add_nsw_neg_const5(i32 %x) {
#0:
ret i1 1
}
Transformation seems to be correct!
-- 296. PassManager<Function> : Skipping NOP
-- 297. PassManager<Function> : Skipping NOP
-- 298. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const6(i32 %x) {
#0:
%add = add nsw i32 %x, 4294967254
%cmp = icmp ne i32 %add, 2147483605
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 299. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_neg_const6(i32 %x) {
#0:
%add = add nsw i32 %x, 4294967254
%cmp = icmp ne i32 %add, 2147483605
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 300. PassManager<Function> : Skipping NOP
-- 301. PassManager<Function> : Skipping NOP
-- 302. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const1(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483647
%cmp = icmp slt i32 %add, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 303. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const1(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483647
%cmp = icmp slt i32 %add, 4294967295
ret i1 %cmp
}
=>
define i1 @add_nsw_pos_const1(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 304. PassManager<Function> : Skipping NOP
-- 305. PassManager<Function> : Skipping NOP
-- 306. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const2(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483647
%cmp = icmp slt i32 %add, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 307. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const2(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483647
%cmp = icmp slt i32 %add, 0
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 308. PassManager<Function> : Skipping NOP
-- 309. PassManager<Function> : Skipping NOP
-- 310. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const3(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483646
%cmp = icmp slt i32 %add, 4294967294
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 311. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const3(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483646
%cmp = icmp slt i32 %add, 4294967294
ret i1 %cmp
}
=>
define i1 @add_nsw_pos_const3(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 312. PassManager<Function> : Skipping NOP
-- 313. PassManager<Function> : Skipping NOP
-- 314. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const4(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483646
%cmp = icmp slt i32 %add, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 315. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const4(i32 %x) {
#0:
%add = add nsw i32 %x, 2147483646
%cmp = icmp slt i32 %add, 4294967295
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 316. PassManager<Function> : Skipping NOP
-- 317. PassManager<Function> : Skipping NOP
-- 318. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const5(i32 %x) {
#0:
%add = add nsw i32 %x, 42
%cmp = icmp eq i32 %add, 2147483689
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 319. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const5(i32 %x) {
#0:
%add = add nsw i32 %x, 42
%cmp = icmp eq i32 %add, 2147483689
ret i1 %cmp
}
=>
define i1 @add_nsw_pos_const5(i32 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 320. PassManager<Function> : Skipping NOP
-- 321. PassManager<Function> : Skipping NOP
-- 322. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const6(i32 %x) {
#0:
%add = add nsw i32 %x, 42
%cmp = icmp eq i32 %add, 2147483690
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 323. InstSimplifyPass
----------------------------------------
define i1 @add_nsw_pos_const6(i32 %x) {
#0:
%add = add nsw i32 %x, 42
%cmp = icmp eq i32 %add, 2147483690
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 324. PassManager<Function> : Skipping NOP
-- 325. PassManager<Function> : Skipping NOP
-- 326. InstSimplifyPass
----------------------------------------
define <2 x i1> @add_nsw_pos_const5_splat_vec(<2 x i32> %x) {
#0:
%add = add nsw <2 x i32> %x, { 42, 42 }
%cmp = icmp ne <2 x i32> %add, { 2147483689, 2147483689 }
ret <2 x i1> %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 327. InstSimplifyPass
----------------------------------------
define <2 x i1> @add_nsw_pos_const5_splat_vec(<2 x i32> %x) {
#0:
%add = add nsw <2 x i32> %x, { 42, 42 }
%cmp = icmp ne <2 x i32> %add, { 2147483689, 2147483689 }
ret <2 x i1> %cmp
}
=>
define <2 x i1> @add_nsw_pos_const5_splat_vec(<2 x i32> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 328. PassManager<Function> : Skipping NOP
-- 329. PassManager<Function> : Skipping NOP
-- 330. InstSimplifyPass
----------------------------------------
define i1 @ne_shl_by_constant_produces_poison(i8 %x) {
#0:
%zx = zext i8 %x to i16
%xor = xor i16 %zx, 32767
%sub = sub nsw i16 %zx, %xor
%poison = shl nsw i16 %sub, 2
%cmp = icmp ne i16 %poison, 1
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 331. InstSimplifyPass
----------------------------------------
define i1 @ne_shl_by_constant_produces_poison(i8 %x) {
#0:
%zx = zext i8 %x to i16
%xor = xor i16 %zx, 32767
%sub = sub nsw i16 %zx, %xor
%poison = shl nsw i16 %sub, 2
%cmp = icmp ne i16 %poison, 1
ret i1 %cmp
}
=>
define i1 @ne_shl_by_constant_produces_poison(i8 %x) {
#0:
ret i1 poison
}
Transformation seems to be correct!
-- 332. PassManager<Function> : Skipping NOP
-- 333. PassManager<Function> : Skipping NOP
-- 334. InstSimplifyPass
----------------------------------------
define i1 @eq_shl_by_constant_produces_poison(i8 %x) {
#0:
%clear_high_bit = and i8 %x, 127
%set_next_high_bits = or i8 %clear_high_bit, 112
%poison = shl nsw i8 %set_next_high_bits, 3
%cmp = icmp eq i8 %poison, 15
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 335. InstSimplifyPass
----------------------------------------
define i1 @eq_shl_by_constant_produces_poison(i8 %x) {
#0:
%clear_high_bit = and i8 %x, 127
%set_next_high_bits = or i8 %clear_high_bit, 112
%poison = shl nsw i8 %set_next_high_bits, 3
%cmp = icmp eq i8 %poison, 15
ret i1 %cmp
}
=>
define i1 @eq_shl_by_constant_produces_poison(i8 %x) {
#0:
ret i1 poison
}
Transformation seems to be correct!
-- 336. PassManager<Function> : Skipping NOP
-- 337. PassManager<Function> : Skipping NOP
-- 338. InstSimplifyPass
----------------------------------------
define i1 @eq_shl_by_variable_produces_poison(i8 %x) {
#0:
%clear_high_bit = and i8 %x, 127
%set_next_high_bits = or i8 %clear_high_bit, 112
%notundef_shiftamt = and i8 %x, 3
%nonzero_shiftamt = or i8 %notundef_shiftamt, 1
%poison = shl nsw i8 %set_next_high_bits, %nonzero_shiftamt
%cmp = icmp eq i8 %poison, 15
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 339. InstSimplifyPass
----------------------------------------
define i1 @eq_shl_by_variable_produces_poison(i8 %x) {
#0:
%clear_high_bit = and i8 %x, 127
%set_next_high_bits = or i8 %clear_high_bit, 112
%notundef_shiftamt = and i8 %x, 3
%nonzero_shiftamt = or i8 %notundef_shiftamt, 1
%poison = shl nsw i8 %set_next_high_bits, %nonzero_shiftamt
%cmp = icmp eq i8 %poison, 15
ret i1 %cmp
}
=>
define i1 @eq_shl_by_variable_produces_poison(i8 %x) {
#0:
ret i1 poison
}
Transformation seems to be correct!
-- 340. PassManager<Function> : Skipping NOP
-- 341. PassManager<Function> : Skipping NOP
-- 342. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant1(i8 %x) {
#0:
%m = mul nuw i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 343. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant1(i8 %x) {
#0:
%m = mul nuw i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
=>
define i1 @mul_nuw_urem_cmp_constant1(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 344. PassManager<Function> : Skipping NOP
-- 345. PassManager<Function> : Skipping NOP
-- 346. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 347. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 348. PassManager<Function> : Skipping NOP
-- 349. PassManager<Function> : Skipping NOP
-- 350. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, undef }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 351. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, undef }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 352. PassManager<Function> : Skipping NOP
-- 353. PassManager<Function> : Skipping NOP
-- 354. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { undef, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 355. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
%m = mul nuw <2 x i8> %x, { undef, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nuw_urem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 356. PassManager<Function> : Skipping NOP
-- 357. PassManager<Function> : Skipping NOP
-- 358. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant2(i8 %x) {
#0:
%m = mul nuw i8 %x, 214
%r = icmp eq i8 %m, 172
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 359. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant2(i8 %x) {
#0:
%m = mul nuw i8 %x, 214
%r = icmp eq i8 %m, 172
ret i1 %r
}
=>
define i1 @mul_nuw_urem_cmp_constant2(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 360. PassManager<Function> : Skipping NOP
-- 361. PassManager<Function> : Skipping NOP
-- 362. InstSimplifyPass
----------------------------------------
define i1 @mul_urem_cmp_constant1(i8 %x) {
#0:
%m = mul i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 363. InstSimplifyPass
----------------------------------------
define i1 @mul_urem_cmp_constant1(i8 %x) {
#0:
%m = mul i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 364. PassManager<Function> : Skipping NOP
-- 365. PassManager<Function> : Skipping NOP
-- 366. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant0(i8 %x) {
#0:
%m = mul nuw i8 %x, 23
%r = icmp eq i8 %m, 0
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 367. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant0(i8 %x) {
#0:
%m = mul nuw i8 %x, 23
%r = icmp eq i8 %m, 0
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 368. PassManager<Function> : Skipping NOP
-- 369. PassManager<Function> : Skipping NOP
-- 370. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant_is_0(i8 %x) {
#0:
%m = mul nuw i8 %x, 42
%r = icmp eq i8 %m, 84
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 371. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_constant_is_0(i8 %x) {
#0:
%m = mul nuw i8 %x, 42
%r = icmp eq i8 %m, 84
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 372. PassManager<Function> : Skipping NOP
-- 373. PassManager<Function> : Skipping NOP
-- 374. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_neg_constant_is_0(i8 %x) {
#0:
%m = mul nuw i8 %x, 43
%r = icmp eq i8 %m, 129
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 375. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_urem_cmp_neg_constant_is_0(i8 %x) {
#0:
%m = mul nuw i8 %x, 43
%r = icmp eq i8 %m, 129
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 376. PassManager<Function> : Skipping NOP
-- 377. PassManager<Function> : Skipping NOP
-- 378. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant1(i8 %x) {
#0:
%m = mul nsw i8 %x, 43
%r = icmp eq i8 %m, 45
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 379. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant1(i8 %x) {
#0:
%m = mul nsw i8 %x, 43
%r = icmp eq i8 %m, 45
ret i1 %r
}
=>
define i1 @mul_nsw_srem_cmp_constant1(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 380. PassManager<Function> : Skipping NOP
-- 381. PassManager<Function> : Skipping NOP
-- 382. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 383. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 384. PassManager<Function> : Skipping NOP
-- 385. PassManager<Function> : Skipping NOP
-- 386. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, undef }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 387. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { 45, 45 }
%r = icmp ne <2 x i8> %m, { 15, undef }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef1(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 388. PassManager<Function> : Skipping NOP
-- 389. PassManager<Function> : Skipping NOP
-- 390. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { undef, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
Transformation seems to be correct! (syntactically equal)
-- 391. InstSimplifyPass
----------------------------------------
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
%m = mul nsw <2 x i8> %x, { undef, 45 }
%r = icmp ne <2 x i8> %m, { 15, 15 }
ret <2 x i1> %r
}
=>
define <2 x i1> @mul_nsw_srem_cmp_constant_vec_splat_undef2(<2 x i8> %x) {
#0:
ret <2 x i1> { 1, 1 }
}
Transformation seems to be correct!
-- 392. PassManager<Function> : Skipping NOP
-- 393. PassManager<Function> : Skipping NOP
-- 394. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant2(i8 %x) {
#0:
%m = mul nsw i8 %x, 43
%r = icmp eq i8 %m, 129
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 395. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant2(i8 %x) {
#0:
%m = mul nsw i8 %x, 43
%r = icmp eq i8 %m, 129
ret i1 %r
}
=>
define i1 @mul_nsw_srem_cmp_constant2(i8 %x) {
#0:
ret i1 0
}
Transformation seems to be correct!
-- 396. PassManager<Function> : Skipping NOP
-- 397. PassManager<Function> : Skipping NOP
-- 398. InstSimplifyPass
----------------------------------------
define i1 @mul_srem_cmp_constant1(i8 %x) {
#0:
%m = mul i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 399. InstSimplifyPass
----------------------------------------
define i1 @mul_srem_cmp_constant1(i8 %x) {
#0:
%m = mul i8 %x, 43
%r = icmp eq i8 %m, 42
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 400. PassManager<Function> : Skipping NOP
-- 401. PassManager<Function> : Skipping NOP
-- 402. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant0(i8 %x) {
#0:
%m = mul nsw i8 %x, 23
%r = icmp eq i8 %m, 0
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 403. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant0(i8 %x) {
#0:
%m = mul nsw i8 %x, 23
%r = icmp eq i8 %m, 0
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 404. PassManager<Function> : Skipping NOP
-- 405. PassManager<Function> : Skipping NOP
-- 406. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant_is_0(i8 %x) {
#0:
%m = mul nsw i8 %x, 42
%r = icmp eq i8 %m, 84
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 407. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_constant_is_0(i8 %x) {
#0:
%m = mul nsw i8 %x, 42
%r = icmp eq i8 %m, 84
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 408. PassManager<Function> : Skipping NOP
-- 409. PassManager<Function> : Skipping NOP
-- 410. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_neg_constant_is_0(i8 %x) {
#0:
%m = mul nsw i8 %x, 214
%r = icmp eq i8 %m, 172
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 411. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_srem_cmp_neg_constant_is_0(i8 %x) {
#0:
%m = mul nsw i8 %x, 214
%r = icmp eq i8 %m, 172
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 412. PassManager<Function> : Skipping NOP
-- 413. PassManager<Function> : Skipping NOP
-- 414. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
%m = mul nsw i8 %x, 0
br label %bb2
bb2:
%r = icmp eq i8 %m, 45
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 415. InstSimplifyPass
----------------------------------------
define i1 @mul_nsw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
%m = mul nsw i8 %x, 0
br label %bb2
bb2:
%r = icmp eq i8 %m, 45
ret i1 %r
}
=>
define i1 @mul_nsw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
br label %bb2
bb2:
ret i1 0
}
Transformation seems to be correct!
-- 416. PassManager<Function> : Skipping NOP
-- 417. PassManager<Function> : Skipping NOP
-- 418. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
%m = mul nuw i8 %x, 0
br label %bb2
bb2:
%r = icmp eq i8 %m, 45
ret i1 %r
}
Transformation seems to be correct! (syntactically equal)
-- 419. InstSimplifyPass
----------------------------------------
define i1 @mul_nuw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
%m = mul nuw i8 %x, 0
br label %bb2
bb2:
%r = icmp eq i8 %m, 45
ret i1 %r
}
=>
define i1 @mul_nuw_by_zero(i8 %x) {
bb1:
br label %bb3
bb3:
br label %bb2
bb2:
ret i1 0
}
Transformation seems to be correct!
-- 420. PassManager<Function> : Skipping NOP
-- 421. PassManager<Function> : Skipping NOP
-- 422. InstSimplifyPass
----------------------------------------
define <2 x i1> @heterogeneous_constvector(<2 x i8> %x) {
#0:
%c = icmp ult <2 x i8> %x, { undef, poison }
ret <2 x i1> %c
}
Transformation seems to be correct! (syntactically equal)
-- 423. InstSimplifyPass
----------------------------------------
define <2 x i1> @heterogeneous_constvector(<2 x i8> %x) {
#0:
%c = icmp ult <2 x i8> %x, { undef, poison }
ret <2 x i1> %c
}
=>
define <2 x i1> @heterogeneous_constvector(<2 x i8> %x) {
#0:
ret <2 x i1> { 0, 0 }
}
Transformation seems to be correct!
-- 424. PassManager<Function> : Skipping NOP
-- 425. PassManager<Function> : Skipping NOP
-- 426. InstSimplifyPass
----------------------------------------
define i1 @icmp_eq_constant_range_attr(i8 %i) {
#0:
%cmp = icmp eq i8 %i, 10
ret i1 %cmp
}
Transformation seems to be correct! (syntactically equal)
-- 427. InstSimplifyPass
----------------------------------------
define i1 @icmp_eq_constant_range_attr(i8 %i) {
#0:
%cmp = icmp eq i8 %i, 10
ret i1 %cmp
}
=>
define i1 @icmp_eq_constant_range_attr(i8 %i) {
#0:
ret i1 0
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch
Example:
i8 %i = #x0a (10)
Source:
i1 %cmp = #x1 (1)
Target:
Source value: #x1 (1)
Target value: #x0 (0)
Pass: InstSimplifyPass
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=instsimplify' '-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_pOHyhzMB_P60I.bc"
------------------- SMT STATS -------------------
Num queries: 237
Num invalid: 0
Num skips: 0
Num trivial: 418 (63.8%)
Num timeout: 0 (0.0%)
Num errors: 0 (0.0%)
Num SAT: 166 (70.0%)
Num UNSAT: 71 (30.0%)
Alive2: Transform doesn't verify; aborting!
RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/icmp-constant.ll -passes=instsimplify -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/icmp-constant.ll + /home/nlopes/alive2/build/opt-alive.sh -passes=instsimplify -S + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/icmp-constant.ll FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstSimplify/icmp-constant.ll