Test source: git
Source: <stdin> -- 1. ModuleToFunctionPassAdaptor ERROR: Unsupported type: <vscale x 1 x i32> -- 1. PassManager<Function> : Skipping NOP -- 2. InstCombinePass ---------------------------------------- define i32 @select_0_or_1_from_bool(i1 %x) { #0: %ext = sext i1 %x to i32 %add = add i32 %ext, 1 ret i32 %add } Transformation seems to be correct! (syntactically equal) -- 3. InstCombinePass ---------------------------------------- define i32 @select_0_or_1_from_bool(i1 %x) { #0: %ext = sext i1 %x to i32 %add = add i32 %ext, 1 ret i32 %add } => define i32 @select_0_or_1_from_bool(i1 %x) { #0: %not.x = xor i1 %x, 1 %add = zext i1 %not.x to i32 ret i32 %add } Transformation seems to be correct! -- 4. PassManager<Function> : Skipping NOP -- 5. PassManager<Function> : Skipping NOP -- 6. InstCombinePass ---------------------------------------- define <2 x i32> @select_0_or_1_from_bool_vec(<2 x i1> %x) { #0: %ext = sext <2 x i1> %x to <2 x i32> %add = add <2 x i32> %ext, { 1, 1 } ret <2 x i32> %add } Transformation seems to be correct! (syntactically equal) -- 7. InstCombinePass ---------------------------------------- define <2 x i32> @select_0_or_1_from_bool_vec(<2 x i1> %x) { #0: %ext = sext <2 x i1> %x to <2 x i32> %add = add <2 x i32> %ext, { 1, 1 } ret <2 x i32> %add } => define <2 x i32> @select_0_or_1_from_bool_vec(<2 x i1> %x) { #0: %not.x = xor <2 x i1> %x, { 1, 1 } %add = zext <2 x i1> %not.x to <2 x i32> ret <2 x i32> %add } Transformation seems to be correct! -- 8. PassManager<Function> : Skipping NOP -- 9. PassManager<Function> : Skipping NOP -- 10. InstCombinePass ---------------------------------------- define i32 @select_C_minus_1_or_C_from_bool(i1 %x) { #0: %ext = sext i1 %x to i32 %add = add i32 %ext, 42 ret i32 %add } Transformation seems to be correct! (syntactically equal) -- 11. InstCombinePass ---------------------------------------- define i32 @select_C_minus_1_or_C_from_bool(i1 %x) { #0: %ext = sext i1 %x to i32 %add = add i32 %ext, 42 ret i32 %add } => define i32 @select_C_minus_1_or_C_from_bool(i1 %x) { #0: %add = select i1 %x, i32 41, i32 42 ret i32 %add } Transformation seems to be correct! -- 12. PassManager<Function> : Skipping NOP -- 13. PassManager<Function> : Skipping NOP -- 14. InstCombinePass ---------------------------------------- define <2 x i32> @select_C_minus_1_or_C_from_bool_vec(<2 x i1> %x) { #0: %ext = sext <2 x i1> %x to <2 x i32> %add = add <2 x i32> %ext, { 42, 43 } ret <2 x i32> %add } Transformation seems to be correct! (syntactically equal) -- 15. InstCombinePass ---------------------------------------- define <2 x i32> @select_C_minus_1_or_C_from_bool_vec(<2 x i1> %x) { #0: %ext = sext <2 x i1> %x to <2 x i32> %add = add <2 x i32> %ext, { 42, 43 } ret <2 x i32> %add } => define <2 x i32> @select_C_minus_1_or_C_from_bool_vec(<2 x i1> %x) { #0: %add = select <2 x i1> %x, <2 x i32> { 41, 42 }, <2 x i32> { 42, 43 } ret <2 x i32> %add } Transformation seems to be correct! -- 16. PassManager<Function> : Skipping NOP -- 17. PassManager<Function> : Skipping NOP -- 18. InstCombinePass ---------------------------------------- define i32 @flip_and_mask(i32 %x) { #0: %shl = shl i32 %x, 31 %shr = ashr i32 %shl, 31 %inc = add i32 %shr, 1 ret i32 %inc } Transformation seems to be correct! (syntactically equal) -- 19. InstCombinePass ---------------------------------------- define i32 @flip_and_mask(i32 %x) { #0: %shl = shl i32 %x, 31 %shr = ashr i32 %shl, 31 %inc = add i32 %shr, 1 ret i32 %inc } => define i32 @flip_and_mask(i32 %x) { #0: %#1 = and i32 %x, 1 %inc = xor i32 %#1, 1 ret i32 %inc } Transformation seems to be correct! -- 20. PassManager<Function> : Skipping NOP -- 21. PassManager<Function> : Skipping NOP -- 22. InstCombinePass ---------------------------------------- define <2 x i8> @flip_and_mask_splat(<2 x i8> %x) { #0: %shl = shl <2 x i8> %x, { 7, 7 } %shr = ashr <2 x i8> %shl, { 7, 7 } %inc = add <2 x i8> %shr, { 1, 1 } ret <2 x i8> %inc } Transformation seems to be correct! (syntactically equal) -- 23. InstCombinePass ---------------------------------------- define <2 x i8> @flip_and_mask_splat(<2 x i8> %x) { #0: %shl = shl <2 x i8> %x, { 7, 7 } %shr = ashr <2 x i8> %shl, { 7, 7 } %inc = add <2 x i8> %shr, { 1, 1 } ret <2 x i8> %inc } => define <2 x i8> @flip_and_mask_splat(<2 x i8> %x) { #0: %#1 = and <2 x i8> %x, { 1, 1 } %inc = xor <2 x i8> %#1, { 1, 1 } ret <2 x i8> %inc } Transformation seems to be correct! -- 24. PassManager<Function> : Skipping NOP -- 25. PassManager<Function> : Skipping NOP -- 26. InstCombinePass ---------------------------------------- define i32 @test1(i32 %A) { #0: %B = add i32 %A, 0 ret i32 %B } Transformation seems to be correct! (syntactically equal) -- 27. InstCombinePass ---------------------------------------- define i32 @test1(i32 %A) { #0: %B = add i32 %A, 0 ret i32 %B } => define i32 @test1(i32 %A) { #0: ret i32 %A } Transformation seems to be correct! -- 28. PassManager<Function> : Skipping NOP -- 29. PassManager<Function> : Skipping NOP -- 30. InstCombinePass ---------------------------------------- define i32 @test2(i32 %A) { #0: %B = add i32 %A, 5 %C = add i32 %B, 4294967291 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 31. InstCombinePass ---------------------------------------- define i32 @test2(i32 %A) { #0: %B = add i32 %A, 5 %C = add i32 %B, 4294967291 ret i32 %C } => define i32 @test2(i32 %A) { #0: ret i32 %A } Transformation seems to be correct! -- 32. PassManager<Function> : Skipping NOP -- 33. PassManager<Function> : Skipping NOP -- 34. InstCombinePass ---------------------------------------- define i32 @test3(i32 %A) { #0: %B = add i32 %A, 5 %C = sub i32 %B, 5 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 35. InstCombinePass ---------------------------------------- define i32 @test3(i32 %A) { #0: %B = add i32 %A, 5 %C = sub i32 %B, 5 ret i32 %C } => define i32 @test3(i32 %A) { #0: ret i32 %A } Transformation seems to be correct! -- 36. PassManager<Function> : Skipping NOP -- 37. PassManager<Function> : Skipping NOP -- 38. InstCombinePass ---------------------------------------- define i32 @test4(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add i32 %B, %C ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 39. InstCombinePass ---------------------------------------- define i32 @test4(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add i32 %B, %C ret i32 %D } => define i32 @test4(i32 %A, i32 %B) { #0: %D = sub i32 %B, %A ret i32 %D } Transformation seems to be correct! -- 40. PassManager<Function> : Skipping NOP -- 41. PassManager<Function> : Skipping NOP -- 42. InstCombinePass ---------------------------------------- define i32 @test5(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add i32 %C, %B ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 43. InstCombinePass ---------------------------------------- define i32 @test5(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add i32 %C, %B ret i32 %D } => define i32 @test5(i32 %A, i32 %B) { #0: %D = sub i32 %B, %A ret i32 %D } Transformation seems to be correct! -- 44. PassManager<Function> : Skipping NOP -- 45. PassManager<Function> : Skipping NOP -- 46. InstCombinePass ---------------------------------------- define i32 @test5_both_nsw(i32 %A, i32 %B) { #0: %C = sub nsw i32 0, %A %D = add nsw i32 %C, %B ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 47. InstCombinePass ---------------------------------------- define i32 @test5_both_nsw(i32 %A, i32 %B) { #0: %C = sub nsw i32 0, %A %D = add nsw i32 %C, %B ret i32 %D } => define i32 @test5_both_nsw(i32 %A, i32 %B) { #0: %D = sub nsw i32 %B, %A ret i32 %D } Transformation seems to be correct! -- 48. PassManager<Function> : Skipping NOP -- 49. PassManager<Function> : Skipping NOP -- 50. InstCombinePass ---------------------------------------- define i32 @test5_neg_nsw(i32 %A, i32 %B) { #0: %C = sub nsw i32 0, %A %D = add i32 %C, %B ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 51. InstCombinePass ---------------------------------------- define i32 @test5_neg_nsw(i32 %A, i32 %B) { #0: %C = sub nsw i32 0, %A %D = add i32 %C, %B ret i32 %D } => define i32 @test5_neg_nsw(i32 %A, i32 %B) { #0: %D = sub i32 %B, %A ret i32 %D } Transformation seems to be correct! -- 52. PassManager<Function> : Skipping NOP -- 53. PassManager<Function> : Skipping NOP -- 54. InstCombinePass ---------------------------------------- define i32 @test5_add_nsw(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add nsw i32 %C, %B ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 55. InstCombinePass ---------------------------------------- define i32 @test5_add_nsw(i32 %A, i32 %B) { #0: %C = sub i32 0, %A %D = add nsw i32 %C, %B ret i32 %D } => define i32 @test5_add_nsw(i32 %A, i32 %B) { #0: %D = sub i32 %B, %A ret i32 %D } Transformation seems to be correct! -- 56. PassManager<Function> : Skipping NOP -- 57. PassManager<Function> : Skipping NOP -- 58. InstCombinePass ---------------------------------------- define <2 x i8> @neg_op0_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %nega = sub <2 x i8> { 0, undef }, %a %r = add <2 x i8> %nega, %b ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 59. InstCombinePass ---------------------------------------- define <2 x i8> @neg_op0_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %nega = sub <2 x i8> { 0, undef }, %a %r = add <2 x i8> %nega, %b ret <2 x i8> %r } => define <2 x i8> @neg_op0_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %r = sub <2 x i8> %b, %a ret <2 x i8> %r } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 60. PassManager<Function> : Skipping NOP -- 61. PassManager<Function> : Skipping NOP -- 62. InstCombinePass ---------------------------------------- define <2 x i8> @neg_neg_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %nega = sub <2 x i8> { undef, 0 }, %a %negb = sub <2 x i8> { undef, 0 }, %b %r = add <2 x i8> %nega, %negb ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 63. InstCombinePass ---------------------------------------- define <2 x i8> @neg_neg_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %nega = sub <2 x i8> { undef, 0 }, %a %negb = sub <2 x i8> { undef, 0 }, %b %r = add <2 x i8> %nega, %negb ret <2 x i8> %r } => define <2 x i8> @neg_neg_vec_undef_elt(<2 x i8> %a, <2 x i8> %b) { #0: %#1 = add <2 x i8> %a, %b %r = sub <2 x i8> { 0, 0 }, %#1 ret <2 x i8> %r } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 64. PassManager<Function> : Skipping NOP -- 65. PassManager<Function> : Skipping NOP -- 66. InstCombinePass ---------------------------------------- define i32 @test6(i32 %A) { #0: %B = mul i32 7, %A %C = add i32 %B, %A ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 67. InstCombinePass ---------------------------------------- define i32 @test6(i32 %A) { #0: %B = mul i32 7, %A %C = add i32 %B, %A ret i32 %C } => define i32 @test6(i32 %A) { #0: %C = shl i32 %A, 3 ret i32 %C } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 68. PassManager<Function> : Skipping NOP -- 69. PassManager<Function> : Skipping NOP -- 70. InstCombinePass ---------------------------------------- define i32 @test7(i32 %A) { #0: %B = mul i32 7, %A %C = add i32 %A, %B ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 71. InstCombinePass ---------------------------------------- define i32 @test7(i32 %A) { #0: %B = mul i32 7, %A %C = add i32 %A, %B ret i32 %C } => define i32 @test7(i32 %A) { #0: %C = shl i32 %A, 3 ret i32 %C } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 72. PassManager<Function> : Skipping NOP -- 73. PassManager<Function> : Skipping NOP -- 74. InstCombinePass ---------------------------------------- define i32 @test8(i32 %A, i32 %B) { #0: %A1 = and i32 %A, 7 %B1 = and i32 %B, 128 %C = add i32 %A1, %B1 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 75. InstCombinePass ---------------------------------------- define i32 @test8(i32 %A, i32 %B) { #0: %A1 = and i32 %A, 7 %B1 = and i32 %B, 128 %C = add i32 %A1, %B1 ret i32 %C } => define i32 @test8(i32 %A, i32 %B) { #0: %A1 = and i32 %A, 7 %B1 = and i32 %B, 128 %C = or disjoint i32 %A1, %B1 ret i32 %C } Transformation seems to be correct! -- 76. PassManager<Function> : Skipping NOP -- 77. PassManager<Function> : Skipping NOP -- 78. InstCombinePass ---------------------------------------- define i32 @test9(i32 %A) { #0: %B = shl i32 %A, 4 %C = add i32 %B, %B ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 79. InstCombinePass ---------------------------------------- define i32 @test9(i32 %A) { #0: %B = shl i32 %A, 4 %C = add i32 %B, %B ret i32 %C } => define i32 @test9(i32 %A) { #0: %C = shl i32 %A, 5 ret i32 %C } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 80. PassManager<Function> : Skipping NOP -- 81. PassManager<Function> : Skipping NOP -- 82. InstCombinePass ---------------------------------------- define i1 @test10(i8 %a, i8 %b) { #0: %add = add i8 %a, %b %c = icmp ne i8 %add, 0 ret i1 %c } Transformation seems to be correct! (syntactically equal) -- 83. InstCombinePass ---------------------------------------- define i1 @test10(i8 %a, i8 %b) { #0: %add = add i8 %a, %b %c = icmp ne i8 %add, 0 ret i1 %c } => define i1 @test10(i8 %a, i8 %b) { #0: %add = sub i8 0, %b %c = icmp ne i8 %add, %a ret i1 %c } Transformation seems to be correct! -- 84. PassManager<Function> : Skipping NOP -- 85. PassManager<Function> : Skipping NOP -- 86. InstCombinePass ---------------------------------------- define <2 x i1> @test10vec(<2 x i8> %a, <2 x i8> %b) { #0: %c = add <2 x i8> %a, %b %d = icmp ne <2 x i8> %c, { 0, 0 } ret <2 x i1> %d } Transformation seems to be correct! (syntactically equal) -- 87. InstCombinePass ---------------------------------------- define <2 x i1> @test10vec(<2 x i8> %a, <2 x i8> %b) { #0: %c = add <2 x i8> %a, %b %d = icmp ne <2 x i8> %c, { 0, 0 } ret <2 x i1> %d } => define <2 x i1> @test10vec(<2 x i8> %a, <2 x i8> %b) { #0: %c = sub <2 x i8> { 0, 0 }, %b %d = icmp ne <2 x i8> %c, %a ret <2 x i1> %d } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 88. PassManager<Function> : Skipping NOP -- 89. PassManager<Function> : Skipping NOP -- 90. InstCombinePass ---------------------------------------- define i1 @test11(i8 %A) { #0: %B = add i8 %A, 255 %c = icmp ne i8 %B, 0 ret i1 %c } Transformation seems to be correct! (syntactically equal) -- 91. InstCombinePass ---------------------------------------- define i1 @test11(i8 %A) { #0: %B = add i8 %A, 255 %c = icmp ne i8 %B, 0 ret i1 %c } => define i1 @test11(i8 %A) { #0: %c = icmp ne i8 %A, 1 ret i1 %c } Transformation seems to be correct! -- 92. PassManager<Function> : Skipping NOP -- 93. PassManager<Function> : Skipping NOP -- 94. InstCombinePass ---------------------------------------- define <2 x i1> @test11vec(<2 x i8> %a) { #0: %b = add <2 x i8> %a, { 255, 255 } %c = icmp ne <2 x i8> %b, { 0, 0 } ret <2 x i1> %c } Transformation seems to be correct! (syntactically equal) -- 95. InstCombinePass ---------------------------------------- define <2 x i1> @test11vec(<2 x i8> %a) { #0: %b = add <2 x i8> %a, { 255, 255 } %c = icmp ne <2 x i8> %b, { 0, 0 } ret <2 x i1> %c } => define <2 x i1> @test11vec(<2 x i8> %a) { #0: %c = icmp ne <2 x i8> %a, { 1, 1 } ret <2 x i1> %c } Transformation seems to be correct! -- 96. PassManager<Function> : Skipping NOP -- 97. PassManager<Function> : Skipping NOP -- 98. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1(i8 %x, i8 %y) { #0: %a = add i8 %y, %x %r = add i8 %a, %x ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 99. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1(i8 %x, i8 %y) { #0: %a = add i8 %y, %x %r = add i8 %a, %x ret i8 %r } => define i8 @reassoc_shl1(i8 %x, i8 %y) { #0: %reass.add = shl i8 %x, 1 %r = add i8 %reass.add, %y ret i8 %r } Transformation seems to be correct! -- 100. PassManager<Function> : Skipping NOP -- 101. PassManager<Function> : Skipping NOP -- 102. InstCombinePass ---------------------------------------- define <2 x i8> @reassoc_shl1_commute1(<2 x i8> %x, <2 x i8> %y) { #0: %a = add <2 x i8> %x, %y %r = add <2 x i8> %a, %x ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 103. InstCombinePass ---------------------------------------- define <2 x i8> @reassoc_shl1_commute1(<2 x i8> %x, <2 x i8> %y) { #0: %a = add <2 x i8> %x, %y %r = add <2 x i8> %a, %x ret <2 x i8> %r } => define <2 x i8> @reassoc_shl1_commute1(<2 x i8> %x, <2 x i8> %y) { #0: %reass.add = shl <2 x i8> %x, { 1, 1 } %r = add <2 x i8> %reass.add, %y ret <2 x i8> %r } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 104. PassManager<Function> : Skipping NOP -- 105. PassManager<Function> : Skipping NOP -- 106. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1_commute2(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %a = add i8 %y, %x %r = add i8 %x, %a ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 107. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1_commute2(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %a = add i8 %y, %x %r = add i8 %x, %a ret i8 %r } => define i8 @reassoc_shl1_commute2(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %reass.add = shl i8 %x, 1 %r = add i8 %y, %reass.add ret i8 %r } Transformation seems to be correct! -- 108. PassManager<Function> : Skipping NOP -- 109. PassManager<Function> : Skipping NOP -- 110. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1_commute3(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %a = add i8 %x, %y %r = add i8 %x, %a ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 111. InstCombinePass ---------------------------------------- define i8 @reassoc_shl1_commute3(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %a = add i8 %x, %y %r = add i8 %x, %a ret i8 %r } => define i8 @reassoc_shl1_commute3(i8 %px, i8 %py) { #0: %x = sdiv i8 42, %px %y = sdiv i8 43, %py %reass.add = shl i8 %x, 1 %r = add i8 %y, %reass.add ret i8 %r } Transformation seems to be correct! -- 112. PassManager<Function> : Skipping NOP -- 113. PassManager<Function> : Skipping NOP -- 114. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @reassoc_shl1_extra_use(i8 %x, i8 %y) { #0: %a = add i8 %y, %x call void @use(i8 %a) %r = add i8 %a, %x ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 115. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @reassoc_shl1_extra_use(i8 %x, i8 %y) { #0: %a = add i8 %y, %x call void @use(i8 %a) %r = add i8 %a, %x ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 116. PassManager<Function> : Skipping NOP -- 117. PassManager<Function> : Skipping NOP -- 118. InstCombinePass ---------------------------------------- define i32 @test13(i32 %A, i32 %B, i32 %C) { #0: %D_OK = add i32 %A, %B %E_OK = add i32 %D_OK, %C %F = add i32 %E_OK, %A ret i32 %F } Transformation seems to be correct! (syntactically equal) -- 119. InstCombinePass ---------------------------------------- define i32 @test13(i32 %A, i32 %B, i32 %C) { #0: %D_OK = add i32 %A, %B %E_OK = add i32 %D_OK, %C %F = add i32 %E_OK, %A ret i32 %F } Transformation seems to be correct! (syntactically equal) -- 120. PassManager<Function> : Skipping NOP -- 121. PassManager<Function> : Skipping NOP -- 122. InstCombinePass ---------------------------------------- define i32 @test14(i32 %offset, i32 %difference) { #0: %tmp.2 = and i32 %difference, 3 %tmp.3_OK = add i32 %tmp.2, %offset %tmp.5.mask = and i32 %difference, 4294967292 %tmp.8 = add i32 %tmp.3_OK, %tmp.5.mask ret i32 %tmp.8 } Transformation seems to be correct! (syntactically equal) -- 123. InstCombinePass ---------------------------------------- define i32 @test14(i32 %offset, i32 %difference) { #0: %tmp.2 = and i32 %difference, 3 %tmp.3_OK = add i32 %tmp.2, %offset %tmp.5.mask = and i32 %difference, 4294967292 %tmp.8 = add i32 %tmp.3_OK, %tmp.5.mask ret i32 %tmp.8 } Transformation seems to be correct! (syntactically equal) -- 124. PassManager<Function> : Skipping NOP -- 125. PassManager<Function> : Skipping NOP -- 126. InstCombinePass ---------------------------------------- define i8 @test15(i8 %A) { #0: %B = add i8 %A, 192 %C = and i8 %B, 16 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 127. InstCombinePass ---------------------------------------- define i8 @test15(i8 %A) { #0: %B = add i8 %A, 192 %C = and i8 %B, 16 ret i8 %C } => define i8 @test15(i8 %A) { #0: %C = and i8 %A, 16 ret i8 %C } Transformation seems to be correct! -- 128. PassManager<Function> : Skipping NOP -- 129. PassManager<Function> : Skipping NOP -- 130. InstCombinePass ---------------------------------------- define i32 @test17(i32 %A) { #0: %B = xor i32 %A, 4294967295 %C = add i32 %B, 1 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 131. InstCombinePass ---------------------------------------- define i32 @test17(i32 %A) { #0: %B = xor i32 %A, 4294967295 %C = add i32 %B, 1 ret i32 %C } => define i32 @test17(i32 %A) { #0: %C = sub i32 0, %A ret i32 %C } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 132. PassManager<Function> : Skipping NOP -- 133. PassManager<Function> : Skipping NOP -- 134. InstCombinePass ---------------------------------------- define i8 @test18(i8 %A) { #0: %B = xor i8 %A, 255 %C = add i8 %B, 17 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 135. InstCombinePass ---------------------------------------- define i8 @test18(i8 %A) { #0: %B = xor i8 %A, 255 %C = add i8 %B, 17 ret i8 %C } => define i8 @test18(i8 %A) { #0: %C = sub i8 16, %A ret i8 %C } Transformation seems to be correct! -- 136. PassManager<Function> : Skipping NOP -- 137. PassManager<Function> : Skipping NOP -- 138. InstCombinePass ---------------------------------------- define i8 @test18_nsw(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nsw i8 %B, 129 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 139. InstCombinePass ---------------------------------------- define i8 @test18_nsw(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nsw i8 %B, 129 ret i8 %C } => define i8 @test18_nsw(i8 %A) { #0: %C = sub nsw i8 128, %A ret i8 %C } Transformation seems to be correct! -- 140. PassManager<Function> : Skipping NOP -- 141. PassManager<Function> : Skipping NOP -- 142. InstCombinePass ---------------------------------------- define i8 @test18_nuw(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nuw i8 %B, 129 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 143. InstCombinePass ---------------------------------------- define i8 @test18_nuw(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nuw i8 %B, 129 ret i8 %C } => define i8 @test18_nuw(i8 %A) { #0: %C = sub i8 128, %A ret i8 %C } Transformation seems to be correct! -- 144. PassManager<Function> : Skipping NOP -- 145. PassManager<Function> : Skipping NOP -- 146. InstCombinePass ---------------------------------------- define i8 @test18_nsw_overflow(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nsw i8 %B, 128 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 147. InstCombinePass ---------------------------------------- define i8 @test18_nsw_overflow(i8 %A) { #0: %B = xor i8 %A, 255 %C = add nsw i8 %B, 128 ret i8 %C } => define i8 @test18_nsw_overflow(i8 %A) { #0: %C = sub i8 127, %A ret i8 %C } Transformation seems to be correct! -- 148. PassManager<Function> : Skipping NOP -- 149. PassManager<Function> : Skipping NOP -- 150. InstCombinePass ---------------------------------------- define <2 x i64> @test18vec(<2 x i64> %A) { #0: %xor = xor <2 x i64> %A, { -1, -1 } %add = add <2 x i64> %xor, { 2, 3 } ret <2 x i64> %add } Transformation seems to be correct! (syntactically equal) -- 151. InstCombinePass ---------------------------------------- define <2 x i64> @test18vec(<2 x i64> %A) { #0: %xor = xor <2 x i64> %A, { -1, -1 } %add = add <2 x i64> %xor, { 2, 3 } ret <2 x i64> %add } => define <2 x i64> @test18vec(<2 x i64> %A) { #0: %add = sub <2 x i64> { 1, 2 }, %A ret <2 x i64> %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 152. PassManager<Function> : Skipping NOP -- 153. PassManager<Function> : Skipping NOP -- 154. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 133, 132 } ret <2 x i8> %C } Transformation seems to be correct! (syntactically equal) -- 155. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 133, 132 } ret <2 x i8> %C } => define <2 x i8> @test18vec_nsw(<2 x i8> %A) { #0: %C = sub nsw <2 x i8> { 132, 131 }, %A ret <2 x i8> %C } Transformation seems to be correct! -- 156. PassManager<Function> : Skipping NOP -- 157. PassManager<Function> : Skipping NOP -- 158. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw_false(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 132, 131 } ret <2 x i8> %C } Transformation seems to be correct! (syntactically equal) -- 159. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw_false(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 132, 131 } ret <2 x i8> %C } => define <2 x i8> @test18vec_nsw_false(<2 x i8> %A) { #0: %C = sub nsw <2 x i8> { 131, 130 }, %A ret <2 x i8> %C } Transformation seems to be correct! -- 160. PassManager<Function> : Skipping NOP -- 161. PassManager<Function> : Skipping NOP -- 162. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nuw(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nuw <2 x i8> %B, { 129, 130 } ret <2 x i8> %C } Transformation seems to be correct! (syntactically equal) -- 163. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nuw(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nuw <2 x i8> %B, { 129, 130 } ret <2 x i8> %C } => define <2 x i8> @test18vec_nuw(<2 x i8> %A) { #0: %C = sub <2 x i8> { 128, 129 }, %A ret <2 x i8> %C } Transformation seems to be correct! -- 164. PassManager<Function> : Skipping NOP -- 165. PassManager<Function> : Skipping NOP -- 166. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw_overflow(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 129, 128 } ret <2 x i8> %C } Transformation seems to be correct! (syntactically equal) -- 167. InstCombinePass ---------------------------------------- define <2 x i8> @test18vec_nsw_overflow(<2 x i8> %A) { #0: %B = xor <2 x i8> %A, { 255, 255 } %C = add nsw <2 x i8> %B, { 129, 128 } ret <2 x i8> %C } => define <2 x i8> @test18vec_nsw_overflow(<2 x i8> %A) { #0: %C = sub <2 x i8> { 128, 127 }, %A ret <2 x i8> %C } Transformation seems to be correct! -- 168. PassManager<Function> : Skipping NOP -- 169. PassManager<Function> : Skipping NOP -- 170. InstCombinePass ---------------------------------------- define i32 @test19(i1 %C) { #0: %A = select i1 %C, i32 1000, i32 10 %V = add i32 %A, 123 ret i32 %V } Transformation seems to be correct! (syntactically equal) -- 171. InstCombinePass ---------------------------------------- define i32 @test19(i1 %C) { #0: %A = select i1 %C, i32 1000, i32 10 %V = add i32 %A, 123 ret i32 %V } => define i32 @test19(i1 %C) { #0: %V = select i1 %C, i32 1123, i32 133 ret i32 %V } Transformation seems to be correct! -- 172. PassManager<Function> : Skipping NOP -- 173. PassManager<Function> : Skipping NOP -- 174. InstCombinePass ---------------------------------------- define <2 x i32> @test19vec(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 1000 }, <2 x i32> { 10, 10 } %V = add <2 x i32> %A, { 123, 123 } ret <2 x i32> %V } Transformation seems to be correct! (syntactically equal) -- 175. InstCombinePass ---------------------------------------- define <2 x i32> @test19vec(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 1000 }, <2 x i32> { 10, 10 } %V = add <2 x i32> %A, { 123, 123 } ret <2 x i32> %V } => define <2 x i32> @test19vec(i1 %C) { #0: %V = select i1 %C, <2 x i32> { 1123, 1123 }, <2 x i32> { 133, 133 } ret <2 x i32> %V } Transformation seems to be correct! -- 176. PassManager<Function> : Skipping NOP -- 177. PassManager<Function> : Skipping NOP -- 178. InstCombinePass ---------------------------------------- define i32 @test20(i32 %x) { #0: %y = xor i32 %x, 2147483648 %z = add nsw i32 %y, 2147483648 ret i32 %z } Transformation seems to be correct! (syntactically equal) -- 179. InstCombinePass ---------------------------------------- define i32 @test20(i32 %x) { #0: %y = xor i32 %x, 2147483648 %z = add nsw i32 %y, 2147483648 ret i32 %z } => define i32 @test20(i32 %x) { #0: ret i32 %x } Transformation seems to be correct! -- 180. PassManager<Function> : Skipping NOP -- 181. PassManager<Function> : Skipping NOP -- 182. InstCombinePass ---------------------------------------- define i32 @xor_sign_bit(i32 %x) { #0: %xor = xor i32 %x, 2147483648 %add = add i32 %xor, 42 ret i32 %add } Transformation seems to be correct! (syntactically equal) -- 183. InstCombinePass ---------------------------------------- define i32 @xor_sign_bit(i32 %x) { #0: %xor = xor i32 %x, 2147483648 %add = add i32 %xor, 42 ret i32 %add } => define i32 @xor_sign_bit(i32 %x) { #0: %add = add i32 %x, 2147483690 ret i32 %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 184. PassManager<Function> : Skipping NOP -- 185. PassManager<Function> : Skipping NOP -- 186. InstCombinePass ---------------------------------------- define <2 x i32> @xor_sign_bit_vec_splat(<2 x i32> %x) { #0: %xor = xor <2 x i32> %x, { 2147483648, 2147483648 } %add = add <2 x i32> %xor, { 42, 42 } ret <2 x i32> %add } Transformation seems to be correct! (syntactically equal) -- 187. InstCombinePass ---------------------------------------- define <2 x i32> @xor_sign_bit_vec_splat(<2 x i32> %x) { #0: %xor = xor <2 x i32> %x, { 2147483648, 2147483648 } %add = add <2 x i32> %xor, { 42, 42 } ret <2 x i32> %add } => define <2 x i32> @xor_sign_bit_vec_splat(<2 x i32> %x) { #0: %add = add <2 x i32> %x, { 2147483690, 2147483690 } ret <2 x i32> %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 188. PassManager<Function> : Skipping NOP -- 189. PassManager<Function> : Skipping NOP -- 190. InstCombinePass ---------------------------------------- define i8 @add_nsw_signbit(i8 %x) { #0: %y = add nsw i8 %x, 128 ret i8 %y } Transformation seems to be correct! (syntactically equal) -- 191. InstCombinePass ---------------------------------------- define i8 @add_nsw_signbit(i8 %x) { #0: %y = add nsw i8 %x, 128 ret i8 %y } => define i8 @add_nsw_signbit(i8 %x) { #0: %y = or i8 %x, 128 ret i8 %y } Transformation seems to be correct! -- 192. PassManager<Function> : Skipping NOP -- 193. PassManager<Function> : Skipping NOP -- 194. InstCombinePass ---------------------------------------- define i8 @add_nuw_signbit(i8 %x) { #0: %y = add nuw i8 %x, 128 ret i8 %y } Transformation seems to be correct! (syntactically equal) -- 195. InstCombinePass ---------------------------------------- define i8 @add_nuw_signbit(i8 %x) { #0: %y = add nuw i8 %x, 128 ret i8 %y } => define i8 @add_nuw_signbit(i8 %x) { #0: %y = or i8 %x, 128 ret i8 %y } Transformation seems to be correct! -- 196. PassManager<Function> : Skipping NOP -- 197. PassManager<Function> : Skipping NOP -- 198. InstCombinePass ---------------------------------------- define i32 @add_nsw_sext_add(i8 %x) { #0: %add = add nsw i8 %x, 42 %ext = sext i8 %add to i32 %r = add i32 %ext, 356 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 199. InstCombinePass ---------------------------------------- define i32 @add_nsw_sext_add(i8 %x) { #0: %add = add nsw i8 %x, 42 %ext = sext i8 %add to i32 %r = add i32 %ext, 356 ret i32 %r } => define i32 @add_nsw_sext_add(i8 %x) { #0: %#1 = sext i8 %x to i32 %r = add nsw i32 %#1, 398 ret i32 %r } Transformation seems to be correct! -- 200. PassManager<Function> : Skipping NOP -- 201. PassManager<Function> : Skipping NOP -- 202. InstCombinePass ---------------------------------------- define i32 @add_nsw_sext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nsw i8 %x, 42 %ext = sext i8 %add to i32 store i32 %ext, ptr %p, align 4 %r = add i32 %ext, 356 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 203. InstCombinePass ---------------------------------------- define i32 @add_nsw_sext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nsw i8 %x, 42 %ext = sext i8 %add to i32 store i32 %ext, ptr %p, align 4 %r = add i32 %ext, 356 ret i32 %r } => define i32 @add_nsw_sext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nsw i8 %x, 42 %ext = sext i8 %add to i32 store i32 %ext, ptr %p, align 4 %r = add nsw i32 %ext, 356 ret i32 %r } Transformation seems to be correct! -- 204. PassManager<Function> : Skipping NOP -- 205. PassManager<Function> : Skipping NOP -- 206. InstCombinePass ---------------------------------------- define <2 x i32> @add_nsw_sext_add_vec_extra_use_2(<2 x i8> %x, ptr %p) { #0: %add = add nsw <2 x i8> %x, { 42, 251 } store <2 x i8> %add, ptr %p, align 2 %ext = sext <2 x i8> %add to <2 x i32> %r = add <2 x i32> %ext, { 356, 12 } ret <2 x i32> %r } Transformation seems to be correct! (syntactically equal) -- 207. InstCombinePass ---------------------------------------- define <2 x i32> @add_nsw_sext_add_vec_extra_use_2(<2 x i8> %x, ptr %p) { #0: %add = add nsw <2 x i8> %x, { 42, 251 } store <2 x i8> %add, ptr %p, align 2 %ext = sext <2 x i8> %add to <2 x i32> %r = add <2 x i32> %ext, { 356, 12 } ret <2 x i32> %r } => define <2 x i32> @add_nsw_sext_add_vec_extra_use_2(<2 x i8> %x, ptr %p) { #0: %add = add nsw <2 x i8> %x, { 42, 251 } store <2 x i8> %add, ptr %p, align 2 %#1 = sext <2 x i8> %x to <2 x i32> %r = add nsw <2 x i32> %#1, { 398, 7 } ret <2 x i32> %r } Transformation seems to be correct! -- 208. PassManager<Function> : Skipping NOP -- 209. PassManager<Function> : Skipping NOP -- 210. InstCombinePass ---------------------------------------- define <2 x i32> @add_nuw_zext_add_vec(<2 x i16> %x) { #0: %add = add nuw <2 x i16> %x, { 65494, 5 } %ext = zext <2 x i16> %add to <2 x i32> %r = add <2 x i32> %ext, { 356, 4294967284 } ret <2 x i32> %r } Transformation seems to be correct! (syntactically equal) -- 211. InstCombinePass ---------------------------------------- define <2 x i32> @add_nuw_zext_add_vec(<2 x i16> %x) { #0: %add = add nuw <2 x i16> %x, { 65494, 5 } %ext = zext <2 x i16> %add to <2 x i32> %r = add <2 x i32> %ext, { 356, 4294967284 } ret <2 x i32> %r } => define <2 x i32> @add_nuw_zext_add_vec(<2 x i16> %x) { #0: %#1 = zext <2 x i16> %x to <2 x i32> %r = add nsw <2 x i32> %#1, { 65850, 4294967289 } ret <2 x i32> %r } Transformation seems to be correct! -- 212. PassManager<Function> : Skipping NOP -- 213. PassManager<Function> : Skipping NOP -- 214. InstCombinePass ---------------------------------------- define i64 @add_nuw_zext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 %ext = zext i8 %add to i64 store i64 %ext, ptr %p, align 4 %r = add i64 %ext, 356 ret i64 %r } Transformation seems to be correct! (syntactically equal) -- 215. InstCombinePass ---------------------------------------- define i64 @add_nuw_zext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 %ext = zext i8 %add to i64 store i64 %ext, ptr %p, align 4 %r = add i64 %ext, 356 ret i64 %r } => define i64 @add_nuw_zext_add_extra_use_1(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 %ext = zext i8 %add to i64 store i64 %ext, ptr %p, align 4 %r = add nsw nuw i64 %ext, 356 ret i64 %r } Transformation seems to be correct! -- 216. PassManager<Function> : Skipping NOP -- 217. PassManager<Function> : Skipping NOP -- 218. InstCombinePass ---------------------------------------- define i64 @add_nuw_zext_add_extra_use_2(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 store i8 %add, ptr %p, align 1 %ext = zext i8 %add to i64 %r = add i64 %ext, -356 ret i64 %r } Transformation seems to be correct! (syntactically equal) -- 219. InstCombinePass ---------------------------------------- define i64 @add_nuw_zext_add_extra_use_2(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 store i8 %add, ptr %p, align 1 %ext = zext i8 %add to i64 %r = add i64 %ext, -356 ret i64 %r } => define i64 @add_nuw_zext_add_extra_use_2(i8 %x, ptr %p) { #0: %add = add nuw i8 %x, 42 store i8 %add, ptr %p, align 1 %#1 = zext i8 %x to i64 %r = add nsw nuw i64 %#1, -314 ret i64 %r } Transformation seems to be correct! -- 220. PassManager<Function> : Skipping NOP -- 221. PassManager<Function> : Skipping NOP -- 222. InstCombinePass ---------------------------------------- define i1 @test21(i32 %x) { #0: %t = add i32 %x, 4 %y = icmp eq i32 %t, 123 ret i1 %y } Transformation seems to be correct! (syntactically equal) -- 223. InstCombinePass ---------------------------------------- define i1 @test21(i32 %x) { #0: %t = add i32 %x, 4 %y = icmp eq i32 %t, 123 ret i1 %y } => define i1 @test21(i32 %x) { #0: %y = icmp eq i32 %x, 119 ret i1 %y } Transformation seems to be correct! -- 224. PassManager<Function> : Skipping NOP -- 225. PassManager<Function> : Skipping NOP -- 226. InstCombinePass ---------------------------------------- define <2 x i1> @test21vec(<2 x i32> %x) { #0: %t = add <2 x i32> %x, { 4, 4 } %y = icmp eq <2 x i32> %t, { 123, 123 } ret <2 x i1> %y } Transformation seems to be correct! (syntactically equal) -- 227. InstCombinePass ---------------------------------------- define <2 x i1> @test21vec(<2 x i32> %x) { #0: %t = add <2 x i32> %x, { 4, 4 } %y = icmp eq <2 x i32> %t, { 123, 123 } ret <2 x i1> %y } => define <2 x i1> @test21vec(<2 x i32> %x) { #0: %y = icmp eq <2 x i32> %x, { 119, 119 } ret <2 x i1> %y } Transformation seems to be correct! -- 228. PassManager<Function> : Skipping NOP -- 229. PassManager<Function> : Skipping NOP -- 230. InstCombinePass ---------------------------------------- define i32 @test22(i32 %V) { #0: %V2 = add i32 %V, 10 switch i32 %V2, label %Default [ i32 20, label %Lab1 i32 30, label %Lab2 ] Lab2: ret i32 1231231 Lab1: ret i32 12312 Default: ret i32 123 } Transformation seems to be correct! (syntactically equal) -- 231. InstCombinePass ---------------------------------------- define i32 @test22(i32 %V) { #0: %V2 = add i32 %V, 10 switch i32 %V2, label %Default [ i32 20, label %Lab1 i32 30, label %Lab2 ] Lab2: ret i32 1231231 Lab1: ret i32 12312 Default: ret i32 123 } => define i32 @test22(i32 %V) { #0: switch i32 %V, label %Default [ i32 10, label %Lab1 i32 20, label %Lab2 ] Lab2: ret i32 1231231 Lab1: ret i32 12312 Default: ret i32 123 } Transformation seems to be correct! -- 232. PassManager<Function> : Skipping NOP -- 233. PassManager<Function> : Skipping NOP -- 234. InstCombinePass ---------------------------------------- define i32 @test23(i1 %C, i32 %a) { entry: br i1 %C, label %endif, label %else else: br label %endif endif: %b.0 = phi i32 [ 0, %entry ], [ 1, %else ] %tmp.4 = add i32 %b.0, 1 ret i32 %tmp.4 } Transformation seems to be correct! (syntactically equal) -- 235. InstCombinePass ---------------------------------------- define i32 @test23(i1 %C, i32 %a) { entry: br i1 %C, label %endif, label %else else: br label %endif endif: %b.0 = phi i32 [ 0, %entry ], [ 1, %else ] %tmp.4 = add i32 %b.0, 1 ret i32 %tmp.4 } => define i32 @test23(i1 %C, i32 %a) { entry: br i1 %C, label %endif, label %else else: br label %endif endif: %b.0 = phi i32 [ 1, %entry ], [ 2, %else ] ret i32 %b.0 } Transformation seems to be correct! -- 236. PassManager<Function> : Skipping NOP -- 237. PassManager<Function> : Skipping NOP -- 238. InstCombinePass ---------------------------------------- define i32 @test24(i32 %A) { #0: %B = add i32 %A, 1 %C = shl i32 %B, 1 %D = sub i32 %C, 2 ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 239. InstCombinePass ---------------------------------------- define i32 @test24(i32 %A) { #0: %B = add i32 %A, 1 %C = shl i32 %B, 1 %D = sub i32 %C, 2 ret i32 %D } => define i32 @test24(i32 %A) { #0: %B = shl i32 %A, 1 ret i32 %B } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 240. PassManager<Function> : Skipping NOP -- 241. PassManager<Function> : Skipping NOP -- 242. InstCombinePass ---------------------------------------- define i64 @test25(i64 %Y) { #0: %tmp.4 = shl i64 %Y, 2 %tmp.12 = shl i64 %Y, 2 %tmp.8 = add i64 %tmp.4, %tmp.12 ret i64 %tmp.8 } Transformation seems to be correct! (syntactically equal) -- 243. InstCombinePass ---------------------------------------- define i64 @test25(i64 %Y) { #0: %tmp.4 = shl i64 %Y, 2 %tmp.12 = shl i64 %Y, 2 %tmp.8 = add i64 %tmp.4, %tmp.12 ret i64 %tmp.8 } => define i64 @test25(i64 %Y) { #0: %tmp.8 = shl i64 %Y, 3 ret i64 %tmp.8 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 244. PassManager<Function> : Skipping NOP -- 245. PassManager<Function> : Skipping NOP -- 246. InstCombinePass ---------------------------------------- define i32 @test26(i32 %A, i32 %B) { #0: %C = add i32 %A, %B %D = sub i32 %C, %B ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 247. InstCombinePass ---------------------------------------- define i32 @test26(i32 %A, i32 %B) { #0: %C = add i32 %A, %B %D = sub i32 %C, %B ret i32 %D } => define i32 @test26(i32 %A, i32 %B) { #0: ret i32 %A } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 248. PassManager<Function> : Skipping NOP -- 249. PassManager<Function> : Skipping NOP -- 250. InstCombinePass ---------------------------------------- define i32 @test27(i1 %C, i32 %X, i32 %Y) { #0: %A = add i32 %X, %Y %B = add i32 %Y, 123 %C.upgrd.1 = select i1 %C, i32 %A, i32 %B %D = sub i32 %C.upgrd.1, %Y ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 251. InstCombinePass ---------------------------------------- define i32 @test27(i1 %C, i32 %X, i32 %Y) { #0: %A = add i32 %X, %Y %B = add i32 %Y, 123 %C.upgrd.1 = select i1 %C, i32 %A, i32 %B %D = sub i32 %C.upgrd.1, %Y ret i32 %D } => define i32 @test27(i1 %C, i32 %X, i32 %Y) { #0: %C.upgrd.1.v = select i1 %C, i32 %X, i32 123 ret i32 %C.upgrd.1.v } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 252. PassManager<Function> : Skipping NOP -- 253. PassManager<Function> : Skipping NOP -- 254. InstCombinePass ---------------------------------------- define i32 @test28(i32 %X) { #0: %Y = add i32 %X, 1234 %Z = sub i32 42, %Y ret i32 %Z } Transformation seems to be correct! (syntactically equal) -- 255. InstCombinePass ---------------------------------------- define i32 @test28(i32 %X) { #0: %Y = add i32 %X, 1234 %Z = sub i32 42, %Y ret i32 %Z } => define i32 @test28(i32 %X) { #0: %Z = sub i32 4294966104, %X ret i32 %Z } Transformation seems to be correct! -- 256. PassManager<Function> : Skipping NOP -- 257. PassManager<Function> : Skipping NOP -- 258. InstCombinePass ---------------------------------------- define i32 @test29(i32 %x, i32 %y) { #0: %tmp.2 = sub i32 %x, %y %tmp.2.mask = and i32 %tmp.2, 63 %tmp.6 = add i32 %tmp.2.mask, %y %tmp.7 = and i32 %tmp.6, 63 %tmp.9 = and i32 %tmp.2, 4294967232 %tmp.10 = or i32 %tmp.7, %tmp.9 ret i32 %tmp.10 } Transformation seems to be correct! (syntactically equal) -- 259. InstCombinePass ---------------------------------------- define i32 @test29(i32 %x, i32 %y) { #0: %tmp.2 = sub i32 %x, %y %tmp.2.mask = and i32 %tmp.2, 63 %tmp.6 = add i32 %tmp.2.mask, %y %tmp.7 = and i32 %tmp.6, 63 %tmp.9 = and i32 %tmp.2, 4294967232 %tmp.10 = or i32 %tmp.7, %tmp.9 ret i32 %tmp.10 } => define i32 @test29(i32 %x, i32 %y) { #0: %tmp.2 = sub i32 %x, %y %tmp.7 = and i32 %x, 63 %tmp.9 = and i32 %tmp.2, 4294967232 %tmp.10 = or disjoint i32 %tmp.7, %tmp.9 ret i32 %tmp.10 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 260. PassManager<Function> : Skipping NOP -- 261. PassManager<Function> : Skipping NOP -- 262. InstCombinePass ---------------------------------------- define i64 @test30(i64 %x) { #0: %tmp.2 = xor i64 %x, -9223372036854775808 %tmp.4 = add i64 %tmp.2, -9223372036854775808 ret i64 %tmp.4 } Transformation seems to be correct! (syntactically equal) -- 263. InstCombinePass ---------------------------------------- define i64 @test30(i64 %x) { #0: %tmp.2 = xor i64 %x, -9223372036854775808 %tmp.4 = add i64 %tmp.2, -9223372036854775808 ret i64 %tmp.4 } => define i64 @test30(i64 %x) { #0: ret i64 %x } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 264. PassManager<Function> : Skipping NOP -- 265. PassManager<Function> : Skipping NOP -- 266. InstCombinePass ---------------------------------------- define i32 @test31(i32 %A) { #0: %B = add i32 %A, 4 %C = mul i32 %B, 5 %D = sub i32 %C, 20 ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 267. InstCombinePass ---------------------------------------- define i32 @test31(i32 %A) { #0: %B = add i32 %A, 4 %C = mul i32 %B, 5 %D = sub i32 %C, 20 ret i32 %D } => define i32 @test31(i32 %A) { #0: %#1 = mul i32 %A, 5 ret i32 %#1 } Transformation seems to be correct! -- 268. PassManager<Function> : Skipping NOP -- 269. PassManager<Function> : Skipping NOP -- 270. InstCombinePass ---------------------------------------- define i32 @test32(i32 %A) { #0: %B = add i32 %A, 4 %C = shl i32 %B, 2 %D = sub i32 %C, 16 ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 271. InstCombinePass ---------------------------------------- define i32 @test32(i32 %A) { #0: %B = add i32 %A, 4 %C = shl i32 %B, 2 %D = sub i32 %C, 16 ret i32 %D } => define i32 @test32(i32 %A) { #0: %B = shl i32 %A, 2 ret i32 %B } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 272. PassManager<Function> : Skipping NOP -- 273. PassManager<Function> : Skipping NOP -- 274. InstCombinePass ---------------------------------------- define i8 @test33(i8 %A) { #0: %B = and i8 %A, 254 %C = add i8 %B, 1 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 275. InstCombinePass ---------------------------------------- define i8 @test33(i8 %A) { #0: %B = and i8 %A, 254 %C = add i8 %B, 1 ret i8 %C } => define i8 @test33(i8 %A) { #0: %C = or i8 %A, 1 ret i8 %C } Transformation seems to be correct! -- 276. PassManager<Function> : Skipping NOP -- 277. PassManager<Function> : Skipping NOP -- 278. InstCombinePass ---------------------------------------- define i8 @test34(i8 %A) { #0: %B = add i8 %A, 64 %C = and i8 %B, 12 ret i8 %C } Transformation seems to be correct! (syntactically equal) -- 279. InstCombinePass ---------------------------------------- define i8 @test34(i8 %A) { #0: %B = add i8 %A, 64 %C = and i8 %B, 12 ret i8 %C } => define i8 @test34(i8 %A) { #0: %C = and i8 %A, 12 ret i8 %C } Transformation seems to be correct! -- 280. PassManager<Function> : Skipping NOP -- 281. PassManager<Function> : Skipping NOP -- 282. InstCombinePass ---------------------------------------- define i8 @masked_add(i8 %x) { #0: %and = and i8 %x, 240 %r = add i8 %and, 96 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 283. InstCombinePass ---------------------------------------- define i8 @masked_add(i8 %x) { #0: %and = and i8 %x, 240 %r = add i8 %and, 96 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 284. PassManager<Function> : Skipping NOP -- 285. PassManager<Function> : Skipping NOP -- 286. InstCombinePass ---------------------------------------- define <2 x i8> @masked_add_splat(<2 x i8> %x) { #0: %and = and <2 x i8> %x, { 192, 192 } %r = add <2 x i8> %and, { 64, 64 } ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 287. InstCombinePass ---------------------------------------- define <2 x i8> @masked_add_splat(<2 x i8> %x) { #0: %and = and <2 x i8> %x, { 192, 192 } %r = add <2 x i8> %and, { 64, 64 } ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 288. PassManager<Function> : Skipping NOP -- 289. PassManager<Function> : Skipping NOP -- 290. InstCombinePass ---------------------------------------- define i8 @not_masked_add(i8 %x) { #0: %and = and i8 %x, 112 %r = add i8 %and, 96 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 291. InstCombinePass ---------------------------------------- define i8 @not_masked_add(i8 %x) { #0: %and = and i8 %x, 112 %r = add i8 %and, 96 ret i8 %r } => define i8 @not_masked_add(i8 %x) { #0: %and = and i8 %x, 112 %r = add nuw i8 %and, 96 ret i8 %r } Transformation seems to be correct! -- 292. PassManager<Function> : Skipping NOP -- 293. PassManager<Function> : Skipping NOP -- 294. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @masked_add_multi_use(i8 %x) { #0: %and = and i8 %x, 240 %r = add i8 %and, 96 call void @use(i8 %and) ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 295. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @masked_add_multi_use(i8 %x) { #0: %and = and i8 %x, 240 %r = add i8 %and, 96 call void @use(i8 %and) ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 296. PassManager<Function> : Skipping NOP -- 297. PassManager<Function> : Skipping NOP -- 298. InstCombinePass ---------------------------------------- define i32 @test35(i32 %a) { #0: %tmpnot = xor i32 %a, 4294967295 %tmp2 = add i32 %tmpnot, %a ret i32 %tmp2 } Transformation seems to be correct! (syntactically equal) -- 299. InstCombinePass ---------------------------------------- define i32 @test35(i32 %a) { #0: %tmpnot = xor i32 %a, 4294967295 %tmp2 = add i32 %tmpnot, %a ret i32 %tmp2 } => define i32 @test35(i32 %a) { #0: ret i32 4294967295 } Transformation seems to be correct! -- 300. PassManager<Function> : Skipping NOP -- 301. PassManager<Function> : Skipping NOP -- 302. InstCombinePass ---------------------------------------- define i32 @test36(i32 %a) { #0: %x = and i32 %a, 4294967294 %y = and i32 %a, 4294967170 %z = add i32 %x, %y %q = and i32 %z, 1 ret i32 %q } Transformation seems to be correct! (syntactically equal) -- 303. InstCombinePass ---------------------------------------- define i32 @test36(i32 %a) { #0: %x = and i32 %a, 4294967294 %y = and i32 %a, 4294967170 %z = add i32 %x, %y %q = and i32 %z, 1 ret i32 %q } => define i32 @test36(i32 %a) { #0: ret i32 0 } Transformation seems to be correct! -- 304. PassManager<Function> : Skipping NOP -- 305. PassManager<Function> : Skipping NOP -- 306. InstCombinePass ---------------------------------------- define i1 @test37(i32 %a, i32 %b) { #0: %add = add i32 %a, %b %cmp = icmp eq i32 %add, %a ret i1 %cmp } Transformation seems to be correct! (syntactically equal) -- 307. InstCombinePass ---------------------------------------- define i1 @test37(i32 %a, i32 %b) { #0: %add = add i32 %a, %b %cmp = icmp eq i32 %add, %a ret i1 %cmp } => define i1 @test37(i32 %a, i32 %b) { #0: %cmp = icmp eq i32 %b, 0 ret i1 %cmp } Transformation seems to be correct! -- 308. PassManager<Function> : Skipping NOP -- 309. PassManager<Function> : Skipping NOP -- 310. InstCombinePass ---------------------------------------- define i1 @test38(i32 %a, i32 %b) { #0: %add = add i32 %a, %b %cmp = icmp eq i32 %add, %b ret i1 %cmp } Transformation seems to be correct! (syntactically equal) -- 311. InstCombinePass ---------------------------------------- define i1 @test38(i32 %a, i32 %b) { #0: %add = add i32 %a, %b %cmp = icmp eq i32 %add, %b ret i1 %cmp } => define i1 @test38(i32 %a, i32 %b) { #0: %cmp = icmp eq i32 %a, 0 ret i1 %cmp } Transformation seems to be correct! -- 312. PassManager<Function> : Skipping NOP -- 313. PassManager<Function> : Skipping NOP -- 314. InstCombinePass ---------------------------------------- define i1 @test39(i32 %a, i32 %b) { #0: %add = add i32 %b, %a %cmp = icmp eq i32 %add, %a ret i1 %cmp } Transformation seems to be correct! (syntactically equal) -- 315. InstCombinePass ---------------------------------------- define i1 @test39(i32 %a, i32 %b) { #0: %add = add i32 %b, %a %cmp = icmp eq i32 %add, %a ret i1 %cmp } => define i1 @test39(i32 %a, i32 %b) { #0: %cmp = icmp eq i32 %b, 0 ret i1 %cmp } Transformation seems to be correct! -- 316. PassManager<Function> : Skipping NOP -- 317. PassManager<Function> : Skipping NOP -- 318. InstCombinePass ---------------------------------------- define i1 @test40(i32 %a, i32 %b) { #0: %add = add i32 %b, %a %cmp = icmp eq i32 %add, %b ret i1 %cmp } Transformation seems to be correct! (syntactically equal) -- 319. InstCombinePass ---------------------------------------- define i1 @test40(i32 %a, i32 %b) { #0: %add = add i32 %b, %a %cmp = icmp eq i32 %add, %b ret i1 %cmp } => define i1 @test40(i32 %a, i32 %b) { #0: %cmp = icmp eq i32 %a, 0 ret i1 %cmp } Transformation seems to be correct! -- 320. PassManager<Function> : Skipping NOP -- 321. PassManager<Function> : Skipping NOP -- 322. InstCombinePass ---------------------------------------- define i64 @test41(i32 %a) { #0: %add = add nuw i32 %a, 16 %zext = zext i32 %add to i64 %sub = add i64 %zext, -1 ret i64 %sub } Transformation seems to be correct! (syntactically equal) -- 323. InstCombinePass ---------------------------------------- define i64 @test41(i32 %a) { #0: %add = add nuw i32 %a, 16 %zext = zext i32 %add to i64 %sub = add i64 %zext, -1 ret i64 %sub } => define i64 @test41(i32 %a) { #0: %#1 = add nuw i32 %a, 15 %sub = zext i32 %#1 to i64 ret i64 %sub } Transformation seems to be correct! -- 324. PassManager<Function> : Skipping NOP -- 325. PassManager<Function> : Skipping NOP -- 326. InstCombinePass ---------------------------------------- define <2 x i64> @test41vec(<2 x i32> %a) { #0: %add = add nuw <2 x i32> %a, { 16, 16 } %zext = zext <2 x i32> %add to <2 x i64> %sub = add <2 x i64> %zext, { -1, -1 } ret <2 x i64> %sub } Transformation seems to be correct! (syntactically equal) -- 327. InstCombinePass ---------------------------------------- define <2 x i64> @test41vec(<2 x i32> %a) { #0: %add = add nuw <2 x i32> %a, { 16, 16 } %zext = zext <2 x i32> %add to <2 x i64> %sub = add <2 x i64> %zext, { -1, -1 } ret <2 x i64> %sub } => define <2 x i64> @test41vec(<2 x i32> %a) { #0: %#1 = add nuw <2 x i32> %a, { 15, 15 } %sub = zext <2 x i32> %#1 to <2 x i64> ret <2 x i64> %sub } Transformation seems to be correct! -- 328. PassManager<Function> : Skipping NOP -- 329. PassManager<Function> : Skipping NOP -- 330. InstCombinePass ---------------------------------------- define <2 x i64> @test41vec_and_multiuse(<2 x i32> %a) { #0: %add = add nuw <2 x i32> %a, { 16, 16 } %zext = zext <2 x i32> %add to <2 x i64> %sub = add <2 x i64> %zext, { -1, -1 } %extrause = add <2 x i64> %zext, %sub ret <2 x i64> %extrause } Transformation seems to be correct! (syntactically equal) -- 331. InstCombinePass ---------------------------------------- define <2 x i64> @test41vec_and_multiuse(<2 x i32> %a) { #0: %add = add nuw <2 x i32> %a, { 16, 16 } %zext = zext <2 x i32> %add to <2 x i64> %sub = add <2 x i64> %zext, { -1, -1 } %extrause = add <2 x i64> %zext, %sub ret <2 x i64> %extrause } => define <2 x i64> @test41vec_and_multiuse(<2 x i32> %a) { #0: %add = add nuw <2 x i32> %a, { 16, 16 } %zext = zext <2 x i32> %add to <2 x i64> %reass.add = shl nsw nuw <2 x i64> %zext, { 1, 1 } %extrause = add nsw <2 x i64> %reass.add, { -1, -1 } ret <2 x i64> %extrause } Transformation seems to be correct! -- 332. PassManager<Function> : Skipping NOP -- 333. PassManager<Function> : Skipping NOP -- 334. InstCombinePass ---------------------------------------- define i32 @test42(i1 %C) { #0: %A = select i1 %C, i32 1000, i32 10 %V = add i32 123, %A ret i32 %V } Transformation seems to be correct! (syntactically equal) -- 335. InstCombinePass ---------------------------------------- define i32 @test42(i1 %C) { #0: %A = select i1 %C, i32 1000, i32 10 %V = add i32 123, %A ret i32 %V } => define i32 @test42(i1 %C) { #0: %V = select i1 %C, i32 1123, i32 133 ret i32 %V } Transformation seems to be correct! -- 336. PassManager<Function> : Skipping NOP -- 337. PassManager<Function> : Skipping NOP -- 338. InstCombinePass ---------------------------------------- define <2 x i32> @test42vec(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 1000 }, <2 x i32> { 10, 10 } %V = add <2 x i32> { 123, 123 }, %A ret <2 x i32> %V } Transformation seems to be correct! (syntactically equal) -- 339. InstCombinePass ---------------------------------------- define <2 x i32> @test42vec(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 1000 }, <2 x i32> { 10, 10 } %V = add <2 x i32> { 123, 123 }, %A ret <2 x i32> %V } => define <2 x i32> @test42vec(i1 %C) { #0: %V = select i1 %C, <2 x i32> { 1123, 1123 }, <2 x i32> { 133, 133 } ret <2 x i32> %V } Transformation seems to be correct! -- 340. PassManager<Function> : Skipping NOP -- 341. PassManager<Function> : Skipping NOP -- 342. InstCombinePass ---------------------------------------- define <2 x i32> @test42vec2(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 2500 }, <2 x i32> { 10, 30 } %V = add <2 x i32> { 123, 333 }, %A ret <2 x i32> %V } Transformation seems to be correct! (syntactically equal) -- 343. InstCombinePass ---------------------------------------- define <2 x i32> @test42vec2(i1 %C) { #0: %A = select i1 %C, <2 x i32> { 1000, 2500 }, <2 x i32> { 10, 30 } %V = add <2 x i32> { 123, 333 }, %A ret <2 x i32> %V } => define <2 x i32> @test42vec2(i1 %C) { #0: %V = select i1 %C, <2 x i32> { 1123, 2833 }, <2 x i32> { 133, 363 } ret <2 x i32> %V } Transformation seems to be correct! -- 344. PassManager<Function> : Skipping NOP -- 345. PassManager<Function> : Skipping NOP -- 346. InstCombinePass ---------------------------------------- define i32 @test55(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi i32 [ 1000, %entry ], [ 10, %delay ] %value = add i32 123, %A ret i32 %value } Transformation seems to be correct! (syntactically equal) -- 347. InstCombinePass ---------------------------------------- define i32 @test55(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi i32 [ 1000, %entry ], [ 10, %delay ] %value = add i32 123, %A ret i32 %value } => define i32 @test55(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi i32 [ 1123, %entry ], [ 133, %delay ] ret i32 %A } Transformation seems to be correct! -- 348. PassManager<Function> : Skipping NOP -- 349. PassManager<Function> : Skipping NOP -- 350. InstCombinePass ---------------------------------------- define <2 x i32> @test43vec(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1000, 1000 }, %entry ], [ { 10, 10 }, %delay ] %value = add <2 x i32> { 123, 123 }, %A ret <2 x i32> %value } Transformation seems to be correct! (syntactically equal) -- 351. InstCombinePass ---------------------------------------- define <2 x i32> @test43vec(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1000, 1000 }, %entry ], [ { 10, 10 }, %delay ] %value = add <2 x i32> { 123, 123 }, %A ret <2 x i32> %value } => define <2 x i32> @test43vec(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1123, 1123 }, %entry ], [ { 133, 133 }, %delay ] ret <2 x i32> %A } Transformation seems to be correct! -- 352. PassManager<Function> : Skipping NOP -- 353. PassManager<Function> : Skipping NOP -- 354. InstCombinePass ---------------------------------------- define <2 x i32> @test43vec2(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1000, 2500 }, %entry ], [ { 10, 30 }, %delay ] %value = add <2 x i32> { 123, 333 }, %A ret <2 x i32> %value } Transformation seems to be correct! (syntactically equal) -- 355. InstCombinePass ---------------------------------------- define <2 x i32> @test43vec2(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1000, 2500 }, %entry ], [ { 10, 30 }, %delay ] %value = add <2 x i32> { 123, 333 }, %A ret <2 x i32> %value } => define <2 x i32> @test43vec2(i1 %which) { entry: br i1 %which, label %final, label %delay delay: br label %final final: %A = phi <2 x i32> [ { 1123, 2833 }, %entry ], [ { 133, 363 }, %delay ] ret <2 x i32> %A } Transformation seems to be correct! -- 356. PassManager<Function> : Skipping NOP -- 357. PassManager<Function> : Skipping NOP -- 358. InstCombinePass ---------------------------------------- define i32 @add_not_increment(i32 %A, i32 %B) { #0: %C = xor i32 %B, 4294967295 %D = add i32 %A, 1 %E = add i32 %D, %C ret i32 %E } Transformation seems to be correct! (syntactically equal) -- 359. InstCombinePass ---------------------------------------- define i32 @add_not_increment(i32 %A, i32 %B) { #0: %C = xor i32 %B, 4294967295 %D = add i32 %A, 1 %E = add i32 %D, %C ret i32 %E } => define i32 @add_not_increment(i32 %A, i32 %B) { #0: %E = sub i32 %A, %B ret i32 %E } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 360. PassManager<Function> : Skipping NOP -- 361. PassManager<Function> : Skipping NOP -- 362. InstCombinePass ---------------------------------------- define <2 x i32> @add_not_increment_vec(<2 x i32> %A, <2 x i32> %B) { #0: %C = xor <2 x i32> %B, { 4294967295, 4294967295 } %D = add <2 x i32> %A, { 1, 1 } %E = add <2 x i32> %D, %C ret <2 x i32> %E } Transformation seems to be correct! (syntactically equal) -- 363. InstCombinePass ---------------------------------------- define <2 x i32> @add_not_increment_vec(<2 x i32> %A, <2 x i32> %B) { #0: %C = xor <2 x i32> %B, { 4294967295, 4294967295 } %D = add <2 x i32> %A, { 1, 1 } %E = add <2 x i32> %D, %C ret <2 x i32> %E } => define <2 x i32> @add_not_increment_vec(<2 x i32> %A, <2 x i32> %B) { #0: %E = sub <2 x i32> %A, %B ret <2 x i32> %E } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 364. PassManager<Function> : Skipping NOP -- 365. PassManager<Function> : Skipping NOP -- 366. InstCombinePass ---------------------------------------- define i32 @add_not_increment_commuted(i32 %A, i32 %B) { #0: %C = xor i32 %B, 4294967295 %D = add i32 %A, 1 %E = add i32 %C, %D ret i32 %E } Transformation seems to be correct! (syntactically equal) -- 367. InstCombinePass ---------------------------------------- define i32 @add_not_increment_commuted(i32 %A, i32 %B) { #0: %C = xor i32 %B, 4294967295 %D = add i32 %A, 1 %E = add i32 %C, %D ret i32 %E } => define i32 @add_not_increment_commuted(i32 %A, i32 %B) { #0: %E = sub i32 %A, %B ret i32 %E } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 368. PassManager<Function> : Skipping NOP -- 369. PassManager<Function> : Skipping NOP -- 370. InstCombinePass ---------------------------------------- define i32 @add_to_sub(i32 %M, i32 %B) { #0: %A = mul i32 %M, 42 %C = xor i32 %B, 4294967295 %D = add i32 %A, %C %E = add i32 %D, 1 ret i32 %E } Transformation seems to be correct! (syntactically equal) -- 371. InstCombinePass ---------------------------------------- define i32 @add_to_sub(i32 %M, i32 %B) { #0: %A = mul i32 %M, 42 %C = xor i32 %B, 4294967295 %D = add i32 %A, %C %E = add i32 %D, 1 ret i32 %E } => define i32 @add_to_sub(i32 %M, i32 %B) { #0: %A = mul i32 %M, 42 %E = sub i32 %A, %B ret i32 %E } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 372. PassManager<Function> : Skipping NOP -- 373. PassManager<Function> : Skipping NOP -- 374. InstCombinePass ---------------------------------------- define i32 @add_to_sub2(i32 %A, i32 %M) { #0: %B = mul i32 %M, 42 %C = xor i32 %B, 4294967295 %D = add i32 %C, %A %E = add i32 %D, 1 ret i32 %E } Transformation seems to be correct! (syntactically equal) -- 375. InstCombinePass ---------------------------------------- define i32 @add_to_sub2(i32 %A, i32 %M) { #0: %B = mul i32 %M, 42 %C = xor i32 %B, 4294967295 %D = add i32 %C, %A %E = add i32 %D, 1 ret i32 %E } => define i32 @add_to_sub2(i32 %A, i32 %M) { #0: %B.neg = mul i32 %M, 4294967254 %E = add i32 %B.neg, %A ret i32 %E } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 376. PassManager<Function> : Skipping NOP -- 377. PassManager<Function> : Skipping NOP -- 378. InstCombinePass ---------------------------------------- define i32 @test44(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294967173 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 379. InstCombinePass ---------------------------------------- define i32 @test44(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294967173 ret i32 %C } => define i32 @test44(i32 %A) { #0: %C = and i32 %A, 4294967172 ret i32 %C } Transformation seems to be correct! -- 380. PassManager<Function> : Skipping NOP -- 381. PassManager<Function> : Skipping NOP -- 382. InstCombinePass ---------------------------------------- define i32 @test44_extra_use(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294967173 %D = mul i32 %B, %C ret i32 %D } Transformation seems to be correct! (syntactically equal) -- 383. InstCombinePass ---------------------------------------- define i32 @test44_extra_use(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294967173 %D = mul i32 %B, %C ret i32 %D } => define i32 @test44_extra_use(i32 %A) { #0: %B = or i32 %A, 123 %C = and i32 %A, 4294967172 %D = mul i32 %B, %C ret i32 %D } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 384. PassManager<Function> : Skipping NOP -- 385. PassManager<Function> : Skipping NOP -- 386. InstCombinePass ---------------------------------------- define i32 @test44_non_matching(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294966975 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 387. InstCombinePass ---------------------------------------- define i32 @test44_non_matching(i32 %A) { #0: %B = or i32 %A, 123 %C = add i32 %B, 4294966975 ret i32 %C } Transformation seems to be correct! (syntactically equal) -- 388. PassManager<Function> : Skipping NOP -- 389. PassManager<Function> : Skipping NOP -- 390. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 123 } %C = add <2 x i32> %B, { 4294967173, 4294967173 } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 391. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 123 } %C = add <2 x i32> %B, { 4294967173, 4294967173 } ret <2 x i32> %C } => define <2 x i32> @test44_vec(<2 x i32> %A) { #0: %C = and <2 x i32> %A, { 4294967172, 4294967172 } ret <2 x i32> %C } Transformation seems to be correct! -- 392. PassManager<Function> : Skipping NOP -- 393. PassManager<Function> : Skipping NOP -- 394. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_non_matching(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 123 } %C = add <2 x i32> %B, { 4294966975, 4294966975 } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 395. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_non_matching(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 123 } %C = add <2 x i32> %B, { 4294966975, 4294966975 } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 396. PassManager<Function> : Skipping NOP -- 397. PassManager<Function> : Skipping NOP -- 398. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_undef(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, undef } %C = add <2 x i32> %B, { 4294967173, undef } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 399. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_undef(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, undef } %C = add <2 x i32> %B, { 4294967173, undef } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 400. PassManager<Function> : Skipping NOP -- 401. PassManager<Function> : Skipping NOP -- 402. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_non_splat(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 456 } %C = add <2 x i32> %B, { 4294967173, 4294966840 } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 403. InstCombinePass ---------------------------------------- define <2 x i32> @test44_vec_non_splat(<2 x i32> %A) { #0: %B = or <2 x i32> %A, { 123, 456 } %C = add <2 x i32> %B, { 4294967173, 4294966840 } ret <2 x i32> %C } Transformation seems to be correct! (syntactically equal) -- 404. PassManager<Function> : Skipping NOP -- 405. PassManager<Function> : Skipping NOP -- 406. InstCombinePass ---------------------------------------- define i32 @lshr_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 407. InstCombinePass ---------------------------------------- define i32 @lshr_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add(i1 %x, i1 %y) { #0: %#1 = xor i1 %x, 1 %#2 = and i1 %#1, %y %r = zext i1 %#2 to i32 ret i32 %r } Transformation seems to be correct! -- 408. PassManager<Function> : Skipping NOP -- 409. PassManager<Function> : Skipping NOP -- 410. InstCombinePass ---------------------------------------- define i5 @and_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i5 %ys = sext i1 %y to i5 %sub = add i5 %xz, %ys %r = and i5 %sub, 30 ret i5 %r } Transformation seems to be correct! (syntactically equal) -- 411. InstCombinePass ---------------------------------------- define i5 @and_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i5 %ys = sext i1 %y to i5 %sub = add i5 %xz, %ys %r = and i5 %sub, 30 ret i5 %r } => define i5 @and_add(i1 %x, i1 %y) { #0: %#1 = xor i1 %x, 1 %#2 = and i1 %#1, %y %r = select i1 %#2, i5 30, i5 0 ret i5 %r } Transformation seems to be correct! -- 412. PassManager<Function> : Skipping NOP -- 413. PassManager<Function> : Skipping NOP -- 414. InstCombinePass ---------------------------------------- define <2 x i8> @ashr_add_commute(<2 x i1> %x, <2 x i1> %y) { #0: %xz = zext <2 x i1> %x to <2 x i8> %ys = sext <2 x i1> %y to <2 x i8> %sub = add nsw <2 x i8> %ys, %xz %r = ashr <2 x i8> %sub, { 1, 1 } ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 415. InstCombinePass ---------------------------------------- define <2 x i8> @ashr_add_commute(<2 x i1> %x, <2 x i1> %y) { #0: %xz = zext <2 x i1> %x to <2 x i8> %ys = sext <2 x i1> %y to <2 x i8> %sub = add nsw <2 x i8> %ys, %xz %r = ashr <2 x i8> %sub, { 1, 1 } ret <2 x i8> %r } => define <2 x i8> @ashr_add_commute(<2 x i1> %x, <2 x i1> %y) { #0: %#1 = xor <2 x i1> %x, { 1, 1 } %#2 = and <2 x i1> %#1, %y %#3 = sext <2 x i1> %#2 to <2 x i8> ret <2 x i8> %#3 } Transformation seems to be correct! -- 416. PassManager<Function> : Skipping NOP -- 417. PassManager<Function> : Skipping NOP -- 418. InstCombinePass ---------------------------------------- define i32 @cmp_math(i32 %x, i32 %y) { #0: %gt = icmp ugt i32 %x, %y %lt = icmp ult i32 %x, %y %xz = zext i1 %gt to i32 %yz = zext i1 %lt to i32 %s = sub i32 %xz, %yz %r = lshr i32 %s, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 419. InstCombinePass ---------------------------------------- define i32 @cmp_math(i32 %x, i32 %y) { #0: %gt = icmp ugt i32 %x, %y %lt = icmp ult i32 %x, %y %xz = zext i1 %gt to i32 %yz = zext i1 %lt to i32 %s = sub i32 %xz, %yz %r = lshr i32 %s, 31 ret i32 %r } => define i32 @cmp_math(i32 %x, i32 %y) { #0: %lt = icmp ult i32 %x, %y %r = zext i1 %lt to i32 ret i32 %r } Transformation seems to be correct! -- 420. PassManager<Function> : Skipping NOP -- 421. PassManager<Function> : Skipping NOP -- 422. InstCombinePass ---------------------------------------- define i32 @lshr_add_nonbool(i2 %x, i1 %y) { #0: %xz = zext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 423. InstCombinePass ---------------------------------------- define i32 @lshr_add_nonbool(i2 %x, i1 %y) { #0: %xz = zext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_nonbool(i2 %x, i1 %y) { #0: %xz = zext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add nsw i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 424. PassManager<Function> : Skipping NOP -- 425. PassManager<Function> : Skipping NOP -- 426. InstCombinePass ---------------------------------------- define i32 @and31_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = and i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 427. InstCombinePass ---------------------------------------- define i32 @and31_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = and i32 %sub, 31 ret i32 %r } => define i32 @and31_add(i1 %x, i1 %y) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add nsw i32 %xz, %ys %r = and i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 428. PassManager<Function> : Skipping NOP -- 429. PassManager<Function> : Skipping NOP -- 430. InstCombinePass ---------------------------------------- define i32 @lshr_add_use(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 store i32 %xz, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 431. InstCombinePass ---------------------------------------- define i32 @lshr_add_use(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 store i32 %xz, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_use(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 store i32 %xz, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add nsw i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 432. PassManager<Function> : Skipping NOP -- 433. PassManager<Function> : Skipping NOP -- 434. InstCombinePass ---------------------------------------- define i32 @lshr_add_use2(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 435. InstCombinePass ---------------------------------------- define i32 @lshr_add_use2(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_use2(i1 %x, i1 %y, ptr %p) { #0: %xz = zext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add nsw i32 %xz, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 436. PassManager<Function> : Skipping NOP -- 437. PassManager<Function> : Skipping NOP -- 438. InstCombinePass ---------------------------------------- define i32 @lshr_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 439. InstCombinePass ---------------------------------------- define i32 @lshr_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_sexts(i1 %x, i1 %y) { #0: %#1 = or i1 %x, %y %r = zext i1 %#1 to i32 ret i32 %r } Transformation seems to be correct! -- 440. PassManager<Function> : Skipping NOP -- 441. PassManager<Function> : Skipping NOP -- 442. InstCombinePass ---------------------------------------- define i5 @and_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i5 %ys = sext i1 %y to i5 %sub = add i5 %xs, %ys %r = and i5 %sub, 30 ret i5 %r } Transformation seems to be correct! (syntactically equal) -- 443. InstCombinePass ---------------------------------------- define i5 @and_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i5 %ys = sext i1 %y to i5 %sub = add i5 %xs, %ys %r = and i5 %sub, 30 ret i5 %r } => define i5 @and_add_sexts(i1 %x, i1 %y) { #0: %#1 = or i1 %x, %y %r = select i1 %#1, i5 30, i5 0 ret i5 %r } Transformation seems to be correct! -- 444. PassManager<Function> : Skipping NOP -- 445. PassManager<Function> : Skipping NOP -- 446. InstCombinePass ---------------------------------------- define <2 x i8> @ashr_add_sexts(<2 x i1> %x, <2 x i1> %y) { #0: %xs = sext <2 x i1> %x to <2 x i8> %ys = sext <2 x i1> %y to <2 x i8> %sub = add nsw <2 x i8> %ys, %xs %r = ashr <2 x i8> %sub, { 1, 1 } ret <2 x i8> %r } Transformation seems to be correct! (syntactically equal) -- 447. InstCombinePass ---------------------------------------- define <2 x i8> @ashr_add_sexts(<2 x i1> %x, <2 x i1> %y) { #0: %xs = sext <2 x i1> %x to <2 x i8> %ys = sext <2 x i1> %y to <2 x i8> %sub = add nsw <2 x i8> %ys, %xs %r = ashr <2 x i8> %sub, { 1, 1 } ret <2 x i8> %r } => define <2 x i8> @ashr_add_sexts(<2 x i1> %x, <2 x i1> %y) { #0: %#1 = or <2 x i1> %y, %x %#2 = sext <2 x i1> %#1 to <2 x i8> ret <2 x i8> %#2 } Transformation seems to be correct! -- 448. PassManager<Function> : Skipping NOP -- 449. PassManager<Function> : Skipping NOP -- 450. InstCombinePass ---------------------------------------- define i32 @cmp_math_sexts(i32 %x, i32 %y) { #0: %gt = icmp ugt i32 %x, %y %lt = icmp ult i32 %x, %y %xz = sext i1 %gt to i32 %yz = zext i1 %lt to i32 %s = sub i32 %xz, %yz %r = lshr i32 %s, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 451. InstCombinePass ---------------------------------------- define i32 @cmp_math_sexts(i32 %x, i32 %y) { #0: %gt = icmp ugt i32 %x, %y %lt = icmp ult i32 %x, %y %xz = sext i1 %gt to i32 %yz = zext i1 %lt to i32 %s = sub i32 %xz, %yz %r = lshr i32 %s, 31 ret i32 %r } => define i32 @cmp_math_sexts(i32 %x, i32 %y) { #0: %.not = icmp ne i32 %x, %y %r = zext i1 %.not to i32 ret i32 %r } Transformation seems to be correct! -- 452. PassManager<Function> : Skipping NOP -- 453. PassManager<Function> : Skipping NOP -- 454. InstCombinePass ---------------------------------------- define i32 @lshr_add_nonbool_sexts(i2 %x, i1 %y) { #0: %xs = sext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 455. InstCombinePass ---------------------------------------- define i32 @lshr_add_nonbool_sexts(i2 %x, i1 %y) { #0: %xs = sext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_nonbool_sexts(i2 %x, i1 %y) { #0: %xs = sext i2 %x to i32 %ys = sext i1 %y to i32 %sub = add nsw i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 456. PassManager<Function> : Skipping NOP -- 457. PassManager<Function> : Skipping NOP -- 458. InstCombinePass ---------------------------------------- define i32 @and31_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = and i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 459. InstCombinePass ---------------------------------------- define i32 @and31_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = and i32 %sub, 31 ret i32 %r } => define i32 @and31_add_sexts(i1 %x, i1 %y) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 %sub = add nsw i32 %xs, %ys %r = and i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 460. PassManager<Function> : Skipping NOP -- 461. PassManager<Function> : Skipping NOP -- 462. InstCombinePass ---------------------------------------- define i32 @lshr_add_use_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 store i32 %xs, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 463. InstCombinePass ---------------------------------------- define i32 @lshr_add_use_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 store i32 %xs, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_use_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 store i32 %xs, ptr %p, align 4 %ys = sext i1 %y to i32 %sub = add nsw i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 464. PassManager<Function> : Skipping NOP -- 465. PassManager<Function> : Skipping NOP -- 466. InstCombinePass ---------------------------------------- define i32 @lshr_add_use2_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! (syntactically equal) -- 467. InstCombinePass ---------------------------------------- define i32 @lshr_add_use2_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } => define i32 @lshr_add_use2_sexts(i1 %x, i1 %y, ptr %p) { #0: %xs = sext i1 %x to i32 %ys = sext i1 %y to i32 store i32 %ys, ptr %p, align 4 %sub = add nsw i32 %xs, %ys %r = lshr i32 %sub, 31 ret i32 %r } Transformation seems to be correct! -- 468. PassManager<Function> : Skipping NOP -- 469. PassManager<Function> : Skipping NOP -- 470. InstCombinePass ---------------------------------------- define i8 @add_like_or_t0(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 15 %r = add i8 %i1, 42 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 471. InstCombinePass ---------------------------------------- define i8 @add_like_or_t0(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 15 %r = add i8 %i1, 42 ret i8 %r } => define i8 @add_like_or_t0(i8 %x) { #0: %i0 = shl i8 %x, 4 %r = add i8 %i0, 57 ret i8 %r } Transformation seems to be correct! -- 472. PassManager<Function> : Skipping NOP -- 473. PassManager<Function> : Skipping NOP -- 474. InstCombinePass ---------------------------------------- define i8 @add_like_or_n1(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 31 %r = add i8 %i1, 42 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 475. InstCombinePass ---------------------------------------- define i8 @add_like_or_n1(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 31 %r = add i8 %i1, 42 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 476. PassManager<Function> : Skipping NOP -- 477. PassManager<Function> : Skipping NOP -- 478. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_like_or_t2_extrause(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 15 call void @use(i8 %i1) %r = add i8 %i1, 42 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 479. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_like_or_t2_extrause(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or i8 %i0, 15 call void @use(i8 %i1) %r = add i8 %i1, 42 ret i8 %r } => declare void @use(i8) define i8 @add_like_or_t2_extrause(i8 %x) { #0: %i0 = shl i8 %x, 4 %i1 = or disjoint i8 %i0, 15 call void @use(i8 %i1) %r = add i8 %i0, 57 ret i8 %r } Transformation seems to be correct! -- 480. PassManager<Function> : Skipping NOP -- 481. PassManager<Function> : Skipping NOP -- 482. InstCombinePass ---------------------------------------- define i8 @add_and_xor(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 255 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 483. InstCombinePass ---------------------------------------- define i8 @add_and_xor(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 255 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } => define i8 @add_and_xor(i8 %x, i8 %y) { #0: %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 484. PassManager<Function> : Skipping NOP -- 485. PassManager<Function> : Skipping NOP -- 486. InstCombinePass ---------------------------------------- define i8 @add_and_xor_wrong_const(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 254 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 487. InstCombinePass ---------------------------------------- define i8 @add_and_xor_wrong_const(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 254 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 488. PassManager<Function> : Skipping NOP -- 489. PassManager<Function> : Skipping NOP -- 490. InstCombinePass ---------------------------------------- define i8 @add_and_xor_wrong_op(i8 %x, i8 %y, i8 %z) { #0: %xor = xor i8 %z, 255 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 491. InstCombinePass ---------------------------------------- define i8 @add_and_xor_wrong_op(i8 %x, i8 %y, i8 %z) { #0: %xor = xor i8 %z, 255 %and = and i8 %xor, %y %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 492. PassManager<Function> : Skipping NOP -- 493. PassManager<Function> : Skipping NOP -- 494. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted1(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %xor = xor i8 %x, 255 %and = and i8 %y, %xor %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 495. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted1(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %xor = xor i8 %x, 255 %and = and i8 %y, %xor %add = add i8 %and, %x ret i8 %add } => define i8 @add_and_xor_commuted1(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 496. PassManager<Function> : Skipping NOP -- 497. PassManager<Function> : Skipping NOP -- 498. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted2(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %xor = xor i8 %x, 255 %and = and i8 %xor, %y %add = add i8 %x, %and ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 499. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted2(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %xor = xor i8 %x, 255 %and = and i8 %xor, %y %add = add i8 %x, %and ret i8 %add } => define i8 @add_and_xor_commuted2(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 500. PassManager<Function> : Skipping NOP -- 501. PassManager<Function> : Skipping NOP -- 502. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted3(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %xor = xor i8 %x, 255 %and = and i8 %y, %xor %add = add i8 %x, %and ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 503. InstCombinePass ---------------------------------------- define i8 @add_and_xor_commuted3(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %xor = xor i8 %x, 255 %and = and i8 %y, %xor %add = add i8 %x, %and ret i8 %add } => define i8 @add_and_xor_commuted3(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 504. PassManager<Function> : Skipping NOP -- 505. PassManager<Function> : Skipping NOP -- 506. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_and_xor_extra_use(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 255 call void @use(i8 %xor) %and = and i8 %xor, %y call void @use(i8 %and) %add = add i8 %and, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 507. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_and_xor_extra_use(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 255 call void @use(i8 %xor) %and = and i8 %xor, %y call void @use(i8 %and) %add = add i8 %and, %x ret i8 %add } => declare void @use(i8) define i8 @add_and_xor_extra_use(i8 %x, i8 %y) { #0: %xor = xor i8 %x, 255 call void @use(i8 %xor) %and = and i8 %xor, %y call void @use(i8 %and) %add = or i8 %y, %x ret i8 %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 508. PassManager<Function> : Skipping NOP -- 509. PassManager<Function> : Skipping NOP -- 510. InstCombinePass ---------------------------------------- define i8 @add_xor_and_const(i8 %x) { #0: %and = and i8 %x, 42 %xor = xor i8 %and, 42 %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 511. InstCombinePass ---------------------------------------- define i8 @add_xor_and_const(i8 %x) { #0: %and = and i8 %x, 42 %xor = xor i8 %and, 42 %add = add i8 %xor, %x ret i8 %add } => define i8 @add_xor_and_const(i8 %x) { #0: %add = or i8 %x, 42 ret i8 %add } Transformation seems to be correct! -- 512. PassManager<Function> : Skipping NOP -- 513. PassManager<Function> : Skipping NOP -- 514. InstCombinePass ---------------------------------------- define i8 @add_xor_and_const_wrong_const(i8 %x) { #0: %and = and i8 %x, 42 %xor = xor i8 %and, 88 %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 515. InstCombinePass ---------------------------------------- define i8 @add_xor_and_const_wrong_const(i8 %x) { #0: %and = and i8 %x, 42 %xor = xor i8 %and, 88 %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 516. PassManager<Function> : Skipping NOP -- 517. PassManager<Function> : Skipping NOP -- 518. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 519. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %x ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 520. PassManager<Function> : Skipping NOP -- 521. PassManager<Function> : Skipping NOP -- 522. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_wrong_op1(i8 %x, i8 %y, i8 %z) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %z %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 523. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_wrong_op1(i8 %x, i8 %y, i8 %z) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %z %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 524. PassManager<Function> : Skipping NOP -- 525. PassManager<Function> : Skipping NOP -- 526. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_wrong_op2(i8 %x, i8 %y, i8 %z) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %z ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 527. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_wrong_op2(i8 %x, i8 %y, i8 %z) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %z ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 528. PassManager<Function> : Skipping NOP -- 529. PassManager<Function> : Skipping NOP -- 530. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted1(i8 %x, i8 %y) { #0: %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 531. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted1(i8 %x, i8 %y) { #0: %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %xor, %x ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted1(i8 %x, i8 %y) { #0: %and = and i8 %y, %x call void @use(i8 %and) %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 532. PassManager<Function> : Skipping NOP -- 533. PassManager<Function> : Skipping NOP -- 534. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted2(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 535. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted2(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %xor, %x ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted2(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 536. PassManager<Function> : Skipping NOP -- 537. PassManager<Function> : Skipping NOP -- 538. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted3(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 539. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted3(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %xor, %x ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted3(i8 %x, i8 %_y) { #0: %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %add = or i8 %y, %x ret i8 %add } Transformation seems to be correct! -- 540. PassManager<Function> : Skipping NOP -- 541. PassManager<Function> : Skipping NOP -- 542. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted4(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %x, %xor ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 543. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted4(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %x, %xor ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted4(i8 %_x, i8 %y) { #0: %x = udiv i8 42, %_x %and = and i8 %x, %y call void @use(i8 %and) %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 544. PassManager<Function> : Skipping NOP -- 545. PassManager<Function> : Skipping NOP -- 546. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted5(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %x, %xor ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 547. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted5(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %and, %y %add = add i8 %x, %xor ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted5(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 548. PassManager<Function> : Skipping NOP -- 549. PassManager<Function> : Skipping NOP -- 550. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted6(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %x, %xor ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 551. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted6(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %x, %xor ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted6(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %x, %y call void @use(i8 %and) %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 552. PassManager<Function> : Skipping NOP -- 553. PassManager<Function> : Skipping NOP -- 554. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted7(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %x, %xor ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 555. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_commuted7(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %xor = xor i8 %y, %and %add = add i8 %x, %xor ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_commuted7(i8 %_x, i8 %_y) { #0: %x = udiv i8 42, %_x %y = udiv i8 42, %_y %and = and i8 %y, %x call void @use(i8 %and) %add = or i8 %x, %y ret i8 %add } Transformation seems to be correct! -- 556. PassManager<Function> : Skipping NOP -- 557. PassManager<Function> : Skipping NOP -- 558. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_extra_use(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y call void @use(i8 %xor) %add = add i8 %xor, %x ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 559. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_xor_and_var_extra_use(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y call void @use(i8 %xor) %add = add i8 %xor, %x ret i8 %add } => declare void @use(i8) define i8 @add_xor_and_var_extra_use(i8 %x, i8 %y) { #0: %and = and i8 %x, %y call void @use(i8 %and) %xor = xor i8 %and, %y call void @use(i8 %xor) %add = or i8 %y, %x ret i8 %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 560. PassManager<Function> : Skipping NOP -- 561. PassManager<Function> : Skipping NOP -- 562. InstCombinePass ---------------------------------------- define i32 @add_add_add(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %A, %B %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 563. InstCombinePass ---------------------------------------- define i32 @add_add_add(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %A, %B %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 564. PassManager<Function> : Skipping NOP -- 565. PassManager<Function> : Skipping NOP -- 566. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute1(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 567. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute1(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 568. PassManager<Function> : Skipping NOP -- 569. PassManager<Function> : Skipping NOP -- 570. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute2(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %C, %E %G = add i32 %F, %D ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 571. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute2(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %C, %E %G = add i32 %F, %D ret i32 %G } => define i32 @add_add_add_commute2(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 572. PassManager<Function> : Skipping NOP -- 573. PassManager<Function> : Skipping NOP -- 574. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute3(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %C, %E %G = add i32 %D, %F ret i32 %G } Transformation seems to be correct! (syntactically equal) -- 575. InstCombinePass ---------------------------------------- define i32 @add_add_add_commute3(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %C, %E %G = add i32 %D, %F ret i32 %G } => define i32 @add_add_add_commute3(i32 %A, i32 %B, i32 %C, i32 %D) { #0: %E = add i32 %B, %A %F = add i32 %E, %C %G = add i32 %F, %D ret i32 %G } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 576. PassManager<Function> : Skipping NOP -- 577. PassManager<Function> : Skipping NOP -- 578. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute1(i8 %x, i8 %y) { #0: %m = mul nsw i8 %x, %y %a = add nsw i8 %m, %x ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 579. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute1(i8 %x, i8 %y) { #0: %m = mul nsw i8 %x, %y %a = add nsw i8 %m, %x ret i8 %a } => define i8 @mul_add_common_factor_commute1(i8 %x, i8 %y) { #0: %x1 = add i8 %y, 1 %a = mul i8 %x1, %x ret i8 %a } Transformation seems to be correct! -- 580. PassManager<Function> : Skipping NOP -- 581. PassManager<Function> : Skipping NOP -- 582. InstCombinePass ---------------------------------------- define <2 x i8> @mul_add_common_factor_commute2(<2 x i8> %x, <2 x i8> %y) { #0: %m = mul nuw <2 x i8> %y, %x %a = add nuw <2 x i8> %m, %x ret <2 x i8> %a } Transformation seems to be correct! (syntactically equal) -- 583. InstCombinePass ---------------------------------------- define <2 x i8> @mul_add_common_factor_commute2(<2 x i8> %x, <2 x i8> %y) { #0: %m = mul nuw <2 x i8> %y, %x %a = add nuw <2 x i8> %m, %x ret <2 x i8> %a } => define <2 x i8> @mul_add_common_factor_commute2(<2 x i8> %x, <2 x i8> %y) { #0: %m1 = add <2 x i8> %y, { 1, 1 } %a = mul nuw <2 x i8> %m1, %x ret <2 x i8> %a } Transformation seems to be correct! -- 584. PassManager<Function> : Skipping NOP -- 585. PassManager<Function> : Skipping NOP -- 586. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute3(i8 %p, i8 %y) { #0: %x = mul i8 %p, %p %m = mul nuw i8 %x, %y %a = add nsw i8 %x, %m ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 587. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute3(i8 %p, i8 %y) { #0: %x = mul i8 %p, %p %m = mul nuw i8 %x, %y %a = add nsw i8 %x, %m ret i8 %a } => define i8 @mul_add_common_factor_commute3(i8 %p, i8 %y) { #0: %x = mul i8 %p, %p %m1 = add i8 %y, 1 %a = mul i8 %x, %m1 ret i8 %a } Transformation seems to be correct! -- 588. PassManager<Function> : Skipping NOP -- 589. PassManager<Function> : Skipping NOP -- 590. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute4(i8 %p, i8 %q) { #0: %x = mul i8 %p, %p %y = mul i8 %q, %q %m = mul nsw i8 %y, %x %a = add nuw i8 %x, %m ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 591. InstCombinePass ---------------------------------------- define i8 @mul_add_common_factor_commute4(i8 %p, i8 %q) { #0: %x = mul i8 %p, %p %y = mul i8 %q, %q %m = mul nsw i8 %y, %x %a = add nuw i8 %x, %m ret i8 %a } => define i8 @mul_add_common_factor_commute4(i8 %p, i8 %q) { #0: %x = mul i8 %p, %p %y = mul i8 %q, %q %m1 = add i8 %y, 1 %a = mul i8 %x, %m1 ret i8 %a } Transformation seems to be correct! -- 592. PassManager<Function> : Skipping NOP -- 593. PassManager<Function> : Skipping NOP -- 594. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @mul_add_common_factor_use(i8 %x, i8 %y) { #0: %m = mul i8 %x, %y call void @use(i8 %m) %a = add i8 %m, %x ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 595. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @mul_add_common_factor_use(i8 %x, i8 %y) { #0: %m = mul i8 %x, %y call void @use(i8 %m) %a = add i8 %m, %x ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 596. PassManager<Function> : Skipping NOP -- 597. PassManager<Function> : Skipping NOP -- 598. InstCombinePass ---------------------------------------- define i8 @not_mul(i8 %x) { #0: %mul = mul nsw i8 %x, 42 %not = xor i8 %mul, 255 %plusx = add nsw i8 %not, %x ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 599. InstCombinePass ---------------------------------------- define i8 @not_mul(i8 %x) { #0: %mul = mul nsw i8 %x, 42 %not = xor i8 %mul, 255 %plusx = add nsw i8 %not, %x ret i8 %plusx } => define i8 @not_mul(i8 %x) { #0: %#1 = mul i8 %x, 215 %plusx = add i8 %#1, 255 ret i8 %plusx } Transformation seems to be correct! -- 600. PassManager<Function> : Skipping NOP -- 601. PassManager<Function> : Skipping NOP -- 602. InstCombinePass ---------------------------------------- define <2 x i8> @not_mul_commute(<2 x i8> %p) { #0: %x = mul <2 x i8> %p, %p %mul = mul nuw <2 x i8> %x, { 214, 214 } %not = xor <2 x i8> %mul, { 255, 255 } %plusx = add nuw <2 x i8> %x, %not ret <2 x i8> %plusx } Transformation seems to be correct! (syntactically equal) -- 603. InstCombinePass ---------------------------------------- define <2 x i8> @not_mul_commute(<2 x i8> %p) { #0: %x = mul <2 x i8> %p, %p %mul = mul nuw <2 x i8> %x, { 214, 214 } %not = xor <2 x i8> %mul, { 255, 255 } %plusx = add nuw <2 x i8> %x, %not ret <2 x i8> %plusx } => define <2 x i8> @not_mul_commute(<2 x i8> %p) { #0: %x = mul <2 x i8> %p, %p %#1 = mul <2 x i8> %x, { 43, 43 } %plusx = add <2 x i8> %#1, { 255, 255 } ret <2 x i8> %plusx } Transformation seems to be correct! -- 604. PassManager<Function> : Skipping NOP -- 605. PassManager<Function> : Skipping NOP -- 606. InstCombinePass ---------------------------------------- define i8 @not_mul_wrong_op(i8 %x, i8 %y) { #0: %mul = mul i8 %x, 42 %not = xor i8 %mul, 255 %plusx = add i8 %not, %y ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 607. InstCombinePass ---------------------------------------- define i8 @not_mul_wrong_op(i8 %x, i8 %y) { #0: %mul = mul i8 %x, 42 %not = xor i8 %mul, 255 %plusx = add i8 %not, %y ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 608. PassManager<Function> : Skipping NOP -- 609. PassManager<Function> : Skipping NOP -- 610. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @not_mul_use1(i8 %x) { #0: %mul = mul nsw i8 %x, 42 call void @use(i8 %mul) %not = xor i8 %mul, 255 %plusx = add nsw i8 %not, %x ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 611. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @not_mul_use1(i8 %x) { #0: %mul = mul nsw i8 %x, 42 call void @use(i8 %mul) %not = xor i8 %mul, 255 %plusx = add nsw i8 %not, %x ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 612. PassManager<Function> : Skipping NOP -- 613. PassManager<Function> : Skipping NOP -- 614. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @not_mul_use2(i8 %x) { #0: %mul = mul i8 %x, 42 %not = xor i8 %mul, 255 call void @use(i8 %not) %plusx = add i8 %not, %x ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 615. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @not_mul_use2(i8 %x) { #0: %mul = mul i8 %x, 42 %not = xor i8 %mul, 255 call void @use(i8 %not) %plusx = add i8 %not, %x ret i8 %plusx } Transformation seems to be correct! (syntactically equal) -- 616. PassManager<Function> : Skipping NOP -- 617. PassManager<Function> : Skipping NOP -- 618. InstCombinePass ---------------------------------------- define i8 @full_ashr_inc(i8 %x) { #0: %a = ashr i8 %x, 7 %r = add i8 %a, 1 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 619. InstCombinePass ---------------------------------------- define i8 @full_ashr_inc(i8 %x) { #0: %a = ashr i8 %x, 7 %r = add i8 %a, 1 ret i8 %r } => define i8 @full_ashr_inc(i8 %x) { #0: %isnotneg = icmp sgt i8 %x, 255 %r = zext i1 %isnotneg to i8 ret i8 %r } Transformation seems to be correct! -- 620. PassManager<Function> : Skipping NOP -- 621. PassManager<Function> : Skipping NOP -- 622. InstCombinePass ---------------------------------------- define <2 x i6> @full_ashr_inc_vec(<2 x i6> %x) { #0: %a = ashr <2 x i6> %x, { 5, poison } %r = add <2 x i6> %a, { 1, 1 } ret <2 x i6> %r } Transformation seems to be correct! (syntactically equal) -- 623. InstCombinePass ---------------------------------------- define <2 x i6> @full_ashr_inc_vec(<2 x i6> %x) { #0: %a = ashr <2 x i6> %x, { 5, poison } %r = add <2 x i6> %a, { 1, 1 } ret <2 x i6> %r } => define <2 x i6> @full_ashr_inc_vec(<2 x i6> %x) { #0: %isnotneg = icmp sgt <2 x i6> %x, { 63, 63 } %r = zext <2 x i1> %isnotneg to <2 x i6> ret <2 x i6> %r } Transformation seems to be correct! -- 624. PassManager<Function> : Skipping NOP -- 625. PassManager<Function> : Skipping NOP -- 626. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @full_ashr_inc_use(i8 %x) { #0: %a = ashr i8 %x, 7 call void @use(i8 %a) %r = add i8 %a, 1 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 627. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @full_ashr_inc_use(i8 %x) { #0: %a = ashr i8 %x, 7 call void @use(i8 %a) %r = add i8 %a, 1 ret i8 %r } => declare void @use(i8) define i8 @full_ashr_inc_use(i8 %x) { #0: %a = ashr i8 %x, 7 call void @use(i8 %a) %r = add nsw i8 %a, 1 ret i8 %r } Transformation seems to be correct! -- 628. PassManager<Function> : Skipping NOP -- 629. PassManager<Function> : Skipping NOP -- 630. InstCombinePass ---------------------------------------- define i8 @not_full_ashr_inc(i8 %x) { #0: %a = ashr i8 %x, 6 %r = add i8 %a, 1 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 631. InstCombinePass ---------------------------------------- define i8 @not_full_ashr_inc(i8 %x) { #0: %a = ashr i8 %x, 6 %r = add i8 %a, 1 ret i8 %r } => define i8 @not_full_ashr_inc(i8 %x) { #0: %a = ashr i8 %x, 6 %r = add nsw i8 %a, 1 ret i8 %r } Transformation seems to be correct! -- 632. PassManager<Function> : Skipping NOP -- 633. PassManager<Function> : Skipping NOP -- 634. InstCombinePass ---------------------------------------- define i8 @full_ashr_not_inc(i8 %x) { #0: %a = ashr i8 %x, 7 %r = add i8 %a, 2 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 635. InstCombinePass ---------------------------------------- define i8 @full_ashr_not_inc(i8 %x) { #0: %a = ashr i8 %x, 7 %r = add i8 %a, 2 ret i8 %r } => define i8 @full_ashr_not_inc(i8 %x) { #0: %a = ashr i8 %x, 7 %r = add nsw i8 %a, 2 ret i8 %r } Transformation seems to be correct! -- 636. PassManager<Function> : Skipping NOP -- 637. PassManager<Function> : Skipping NOP -- 638. InstCombinePass ---------------------------------------- define i8 @select_negate_or_zero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 0, i8 %negx %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 639. InstCombinePass ---------------------------------------- define i8 @select_negate_or_zero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 0, i8 %negx %add = add i8 %sel, %y ret i8 %add } => define i8 @select_negate_or_zero(i1 %b, i8 %x, i8 %y) { #0: %#1 = select i1 %b, i8 0, i8 %x %add1 = sub i8 %y, %#1 ret i8 %add1 } Transformation seems to be correct! -- 640. PassManager<Function> : Skipping NOP -- 641. PassManager<Function> : Skipping NOP -- 642. InstCombinePass ---------------------------------------- define <2 x i8> @select_negate_or_zero_commute(<2 x i1> %b, <2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %negx = sub <2 x i8> { poison, 0 }, %x %sel = select <2 x i1> %b, <2 x i8> { poison, 0 }, <2 x i8> %negx %add = add <2 x i8> %y, %sel ret <2 x i8> %add } Transformation seems to be correct! (syntactically equal) -- 643. InstCombinePass ---------------------------------------- define <2 x i8> @select_negate_or_zero_commute(<2 x i1> %b, <2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %negx = sub <2 x i8> { poison, 0 }, %x %sel = select <2 x i1> %b, <2 x i8> { poison, 0 }, <2 x i8> %negx %add = add <2 x i8> %y, %sel ret <2 x i8> %add } => define <2 x i8> @select_negate_or_zero_commute(<2 x i1> %b, <2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %#1 = select <2 x i1> %b, <2 x i8> { 0, 0 }, <2 x i8> %x %add1 = sub <2 x i8> %y, %#1 ret <2 x i8> %add1 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 644. PassManager<Function> : Skipping NOP -- 645. PassManager<Function> : Skipping NOP -- 646. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @select_negate_or_zero_swap(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x call void @use(i8 %negx) %sel = select i1 %b, i8 %negx, i8 0 %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 647. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @select_negate_or_zero_swap(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x call void @use(i8 %negx) %sel = select i1 %b, i8 %negx, i8 0 %add = add i8 %sel, %y ret i8 %add } => declare void @use(i8) define i8 @select_negate_or_zero_swap(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x call void @use(i8 %negx) %#1 = select i1 %b, i8 %x, i8 0 %add1 = sub i8 %y, %#1 ret i8 %add1 } Transformation seems to be correct! -- 648. PassManager<Function> : Skipping NOP -- 649. PassManager<Function> : Skipping NOP -- 650. InstCombinePass ---------------------------------------- define i8 @select_negate_or_zero_swap_commute(i1 %b, i8 %x, i8 %p) { #0: %y = mul i8 %p, %p %negx = sub i8 0, %x %sel = select i1 %b, i8 %negx, i8 0 %add = add i8 %y, %sel ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 651. InstCombinePass ---------------------------------------- define i8 @select_negate_or_zero_swap_commute(i1 %b, i8 %x, i8 %p) { #0: %y = mul i8 %p, %p %negx = sub i8 0, %x %sel = select i1 %b, i8 %negx, i8 0 %add = add i8 %y, %sel ret i8 %add } => define i8 @select_negate_or_zero_swap_commute(i1 %b, i8 %x, i8 %p) { #0: %y = mul i8 %p, %p %#1 = select i1 %b, i8 %x, i8 0 %add1 = sub i8 %y, %#1 ret i8 %add1 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 652. PassManager<Function> : Skipping NOP -- 653. PassManager<Function> : Skipping NOP -- 654. InstCombinePass ---------------------------------------- define i8 @select_negate_or_nonzero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 42, i8 %negx %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 655. InstCombinePass ---------------------------------------- define i8 @select_negate_or_nonzero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 42, i8 %negx %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 656. PassManager<Function> : Skipping NOP -- 657. PassManager<Function> : Skipping NOP -- 658. InstCombinePass ---------------------------------------- define i8 @select_nonnegate_or_zero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 42, %x %sel = select i1 %b, i8 0, i8 %negx %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 659. InstCombinePass ---------------------------------------- define i8 @select_nonnegate_or_zero(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 42, %x %sel = select i1 %b, i8 0, i8 %negx %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 660. PassManager<Function> : Skipping NOP -- 661. PassManager<Function> : Skipping NOP -- 662. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @select_negate_or_nonzero_use(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 0, i8 %negx call void @use(i8 %sel) %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 663. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @select_negate_or_nonzero_use(i1 %b, i8 %x, i8 %y) { #0: %negx = sub i8 0, %x %sel = select i1 %b, i8 0, i8 %negx call void @use(i8 %sel) %add = add i8 %sel, %y ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 664. PassManager<Function> : Skipping NOP -- 665. PassManager<Function> : Skipping NOP -- 666. InstCombinePass ---------------------------------------- define i5 @select_negate_not(i1 %b, i5 %x, i5 %y) { #0: %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %noty, i5 %negx %add = add i5 %sel, %y ret i5 %add } Transformation seems to be correct! (syntactically equal) -- 667. InstCombinePass ---------------------------------------- define i5 @select_negate_not(i1 %b, i5 %x, i5 %y) { #0: %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %noty, i5 %negx %add = add i5 %sel, %y ret i5 %add } => define i5 @select_negate_not(i1 %b, i5 %x, i5 %y) { #0: %#1 = sub i5 %y, %x %add1 = select i1 %b, i5 31, i5 %#1 ret i5 %add1 } Transformation seems to be correct! -- 668. PassManager<Function> : Skipping NOP -- 669. PassManager<Function> : Skipping NOP -- 670. InstCombinePass ---------------------------------------- define i5 @select_negate_not_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %noty, i5 %negx %add = add i5 %y, %sel ret i5 %add } Transformation seems to be correct! (syntactically equal) -- 671. InstCombinePass ---------------------------------------- define i5 @select_negate_not_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %noty, i5 %negx %add = add i5 %y, %sel ret i5 %add } => define i5 @select_negate_not_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %#1 = sub i5 %y, %x %add1 = select i1 %b, i5 31, i5 %#1 ret i5 %add1 } Transformation seems to be correct! -- 672. PassManager<Function> : Skipping NOP -- 673. PassManager<Function> : Skipping NOP -- 674. InstCombinePass ---------------------------------------- define i5 @select_negate_not_swap(i1 %b, i5 %x, i5 %y) { #0: %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %negx, i5 %noty %add = add i5 %sel, %y ret i5 %add } Transformation seems to be correct! (syntactically equal) -- 675. InstCombinePass ---------------------------------------- define i5 @select_negate_not_swap(i1 %b, i5 %x, i5 %y) { #0: %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %negx, i5 %noty %add = add i5 %sel, %y ret i5 %add } => define i5 @select_negate_not_swap(i1 %b, i5 %x, i5 %y) { #0: %#1 = sub i5 %y, %x %add1 = select i1 %b, i5 %#1, i5 31 ret i5 %add1 } Transformation seems to be correct! -- 676. PassManager<Function> : Skipping NOP -- 677. PassManager<Function> : Skipping NOP -- 678. InstCombinePass ---------------------------------------- define i5 @select_negate_not_swap_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %negx, i5 %noty %add = add i5 %y, %sel ret i5 %add } Transformation seems to be correct! (syntactically equal) -- 679. InstCombinePass ---------------------------------------- define i5 @select_negate_not_swap_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %negx = sub i5 0, %x %noty = xor i5 %y, 31 %sel = select i1 %b, i5 %negx, i5 %noty %add = add i5 %y, %sel ret i5 %add } => define i5 @select_negate_not_swap_commute(i1 %b, i5 %x, i5 %p) { #0: %y = mul i5 %p, %p %#1 = sub i5 %y, %x %add1 = select i1 %b, i5 %#1, i5 31 ret i5 %add1 } Transformation seems to be correct! -- 680. PassManager<Function> : Skipping NOP -- 681. PassManager<Function> : Skipping NOP -- 682. InstCombinePass ---------------------------------------- define i32 @add_select_sub_both_arms_simplify(i1 %b, i32 %a) { #0: %sub = sub i32 99, %a %sel = select i1 %b, i32 0, i32 %sub %add = add i32 %sel, %a ret i32 %add } Transformation seems to be correct! (syntactically equal) -- 683. InstCombinePass ---------------------------------------- define i32 @add_select_sub_both_arms_simplify(i1 %b, i32 %a) { #0: %sub = sub i32 99, %a %sel = select i1 %b, i32 0, i32 %sub %add = add i32 %sel, %a ret i32 %add } => define i32 @add_select_sub_both_arms_simplify(i1 %b, i32 %a) { #0: %add = select i1 %b, i32 %a, i32 99 ret i32 %add } Transformation seems to be correct! -- 684. PassManager<Function> : Skipping NOP -- 685. PassManager<Function> : Skipping NOP -- 686. InstCombinePass ---------------------------------------- define <2 x i8> @add_select_sub_both_arms_simplify_swap(<2 x i1> %b, <2 x i8> %a) { #0: %sub = sub <2 x i8> { 42, 99 }, %a %sel = select <2 x i1> %b, <2 x i8> %sub, <2 x i8> { 0, 0 } %add = add <2 x i8> %sel, %a ret <2 x i8> %add } Transformation seems to be correct! (syntactically equal) -- 687. InstCombinePass ---------------------------------------- define <2 x i8> @add_select_sub_both_arms_simplify_swap(<2 x i1> %b, <2 x i8> %a) { #0: %sub = sub <2 x i8> { 42, 99 }, %a %sel = select <2 x i1> %b, <2 x i8> %sub, <2 x i8> { 0, 0 } %add = add <2 x i8> %sel, %a ret <2 x i8> %add } => define <2 x i8> @add_select_sub_both_arms_simplify_swap(<2 x i1> %b, <2 x i8> %a) { #0: %add = select <2 x i1> %b, <2 x i8> { 42, 99 }, <2 x i8> %a ret <2 x i8> %add } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 688. PassManager<Function> : Skipping NOP -- 689. PassManager<Function> : Skipping NOP -- 690. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_select_sub_both_arms_simplify_use1(i1 %b, i8 %a) { #0: %sub = sub i8 42, %a call void @use(i8 %sub) %sel = select i1 %b, i8 0, i8 %sub %add = add i8 %sel, %a ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 691. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_select_sub_both_arms_simplify_use1(i1 %b, i8 %a) { #0: %sub = sub i8 42, %a call void @use(i8 %sub) %sel = select i1 %b, i8 0, i8 %sub %add = add i8 %sel, %a ret i8 %add } => declare void @use(i8) define i8 @add_select_sub_both_arms_simplify_use1(i1 %b, i8 %a) { #0: %sub = sub i8 42, %a call void @use(i8 %sub) %add = select i1 %b, i8 %a, i8 42 ret i8 %add } Transformation seems to be correct! -- 692. PassManager<Function> : Skipping NOP -- 693. PassManager<Function> : Skipping NOP -- 694. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_select_sub_both_arms_simplify_use2(i1 %b, i8 %a) { #0: %sub = sub i8 42, %a %sel = select i1 %b, i8 0, i8 %sub call void @use(i8 %sel) %add = add i8 %sel, %a ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 695. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @add_select_sub_both_arms_simplify_use2(i1 %b, i8 %a) { #0: %sub = sub i8 42, %a %sel = select i1 %b, i8 0, i8 %sub call void @use(i8 %sel) %add = add i8 %sel, %a ret i8 %add } Transformation seems to be correct! (syntactically equal) -- 696. PassManager<Function> : Skipping NOP -- 697. PassManager<Function> : Skipping NOP -- 698. InstCombinePass ---------------------------------------- declare void @use(i8) define i5 @demand_low_bits_uses(i8 %x, i8 %y) { #0: %m = mul i8 %x, 224 %a = add i8 %m, %y call void @use(i8 %a) %r = trunc i8 %a to i5 ret i5 %r } Transformation seems to be correct! (syntactically equal) -- 699. InstCombinePass ---------------------------------------- declare void @use(i8) define i5 @demand_low_bits_uses(i8 %x, i8 %y) { #0: %m = mul i8 %x, 224 %a = add i8 %m, %y call void @use(i8 %a) %r = trunc i8 %a to i5 ret i5 %r } => declare void @use(i8) define i5 @demand_low_bits_uses(i8 %x, i8 %y) { #0: %#1 = shl i8 %x, 5 %a = sub i8 %y, %#1 call void @use(i8 %a) %r = trunc i8 %y to i5 ret i5 %r } Transformation seems to be correct! -- 700. PassManager<Function> : Skipping NOP -- 701. PassManager<Function> : Skipping NOP -- 702. InstCombinePass ---------------------------------------- declare void @use(i8) define i6 @demand_low_bits_uses_extra_bit(i8 %x, i8 %y) { #0: %m = mul i8 %x, 224 %a = add i8 %m, %y call void @use(i8 %a) %r = trunc i8 %a to i6 ret i6 %r } Transformation seems to be correct! (syntactically equal) -- 703. InstCombinePass ---------------------------------------- declare void @use(i8) define i6 @demand_low_bits_uses_extra_bit(i8 %x, i8 %y) { #0: %m = mul i8 %x, 224 %a = add i8 %m, %y call void @use(i8 %a) %r = trunc i8 %a to i6 ret i6 %r } => declare void @use(i8) define i6 @demand_low_bits_uses_extra_bit(i8 %x, i8 %y) { #0: %#1 = shl i8 %x, 5 %a = sub i8 %y, %#1 call void @use(i8 %a) %r = trunc i8 %a to i6 ret i6 %r } Transformation seems to be correct! -- 704. PassManager<Function> : Skipping NOP -- 705. PassManager<Function> : Skipping NOP -- 706. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @demand_low_bits_uses_commute(i8 %x, i8 %p, i8 %z) { #0: %y = mul i8 %p, %p %m = and i8 %x, 192 %a = add i8 %y, %m call void @use(i8 %a) %s = sub i8 %a, %z %r = shl i8 %s, 2 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 707. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @demand_low_bits_uses_commute(i8 %x, i8 %p, i8 %z) { #0: %y = mul i8 %p, %p %m = and i8 %x, 192 %a = add i8 %y, %m call void @use(i8 %a) %s = sub i8 %a, %z %r = shl i8 %s, 2 ret i8 %r } => declare void @use(i8) define i8 @demand_low_bits_uses_commute(i8 %x, i8 %p, i8 %z) { #0: %y = mul i8 %p, %p %m = and i8 %x, 192 %a = add i8 %y, %m call void @use(i8 %a) %s = sub i8 %y, %z %r = shl i8 %s, 2 ret i8 %r } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 708. PassManager<Function> : Skipping NOP -- 709. PassManager<Function> : Skipping NOP -- 710. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @demand_low_bits_uses_commute_extra_bit(i8 %x, i8 %p, i8 %z) { #0: %y = mul i8 %p, %p %m = and i8 %x, 192 %a = add i8 %y, %m call void @use(i8 %a) %s = sub i8 %a, %z %r = shl i8 %s, 1 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 711. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @demand_low_bits_uses_commute_extra_bit(i8 %x, i8 %p, i8 %z) { #0: %y = mul i8 %p, %p %m = and i8 %x, 192 %a = add i8 %y, %m call void @use(i8 %a) %s = sub i8 %a, %z %r = shl i8 %s, 1 ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 712. PassManager<Function> : Skipping NOP -- 713. PassManager<Function> : Skipping NOP -- 714. InstCombinePass ---------------------------------------- define {i64, i64} @PR57576(i64 noundef %x, i64 noundef %y, i64 noundef %z, i64 noundef %w) { #0: %zx = zext i64 noundef %x to i128 %zy = zext i64 noundef %y to i128 %zw = zext i64 noundef %w to i128 %zz = zext i64 noundef %z to i128 %shy = shl nuw i128 %zy, 64 %mw = mul i128 %zw, 340282366920938463444927863358058659840 %xy = or i128 %shy, %zx %sub = sub i128 %xy, %zz %add = add i128 %sub, %mw %t = trunc i128 %add to i64 %h = lshr i128 %add, 64 %t2 = trunc i128 %h to i64 %r1 = insertvalue {i64, i64} poison, i64 %t, 0 %r2 = insertvalue {i64, i64} %r1, i64 %t2, 1 ret {i64, i64} %r2 } Transformation seems to be correct! (syntactically equal) -- 715. InstCombinePass ---------------------------------------- define {i64, i64} @PR57576(i64 noundef %x, i64 noundef %y, i64 noundef %z, i64 noundef %w) { #0: %zx = zext i64 noundef %x to i128 %zy = zext i64 noundef %y to i128 %zw = zext i64 noundef %w to i128 %zz = zext i64 noundef %z to i128 %shy = shl nuw i128 %zy, 64 %mw = mul i128 %zw, 340282366920938463444927863358058659840 %xy = or i128 %shy, %zx %sub = sub i128 %xy, %zz %add = add i128 %sub, %mw %t = trunc i128 %add to i64 %h = lshr i128 %add, 64 %t2 = trunc i128 %h to i64 %r1 = insertvalue {i64, i64} poison, i64 %t, 0 %r2 = insertvalue {i64, i64} %r1, i64 %t2, 1 ret {i64, i64} %r2 } => define {i64, i64} @PR57576(i64 noundef %x, i64 noundef %y, i64 noundef %z, i64 noundef %w) { #0: %zx = zext i64 noundef %x to i128 %zy = zext i64 noundef %y to i128 %zz = zext i64 noundef %z to i128 %shy = shl nuw i128 %zy, 64 %xy = or disjoint i128 %shy, %zx %sub = sub i128 %xy, %zz %t = trunc i128 %sub to i64 %#1 = lshr i128 %sub, 64 %.tr = trunc i128 %#1 to i64 %.narrow = sub i64 %.tr, noundef %w %r1 = insertvalue {i64, i64} poison, i64 %t, 0 %r2 = insertvalue {i64, i64} %r1, i64 %.narrow, 1 ret {i64, i64} %r2 } Transformation seems to be correct! -- 716. PassManager<Function> : Skipping NOP -- 717. PassManager<Function> : Skipping NOP -- 718. InstCombinePass ---------------------------------------- define i8 @mul_negpow2(i8 %x, i8 %y) { #0: %m = mul i8 %x, 254 %a = add i8 %m, %y ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 719. InstCombinePass ---------------------------------------- define i8 @mul_negpow2(i8 %x, i8 %y) { #0: %m = mul i8 %x, 254 %a = add i8 %m, %y ret i8 %a } => define i8 @mul_negpow2(i8 %x, i8 %y) { #0: %#1 = shl i8 %x, 1 %a = sub i8 %y, %#1 ret i8 %a } Transformation seems to be correct! -- 720. PassManager<Function> : Skipping NOP -- 721. PassManager<Function> : Skipping NOP -- 722. InstCombinePass ---------------------------------------- define <2 x i8> @mul_negpow2_commute_vec(<2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %m = mul <2 x i8> %x, { 248, 248 } %a = add <2 x i8> %y, %m ret <2 x i8> %a } Transformation seems to be correct! (syntactically equal) -- 723. InstCombinePass ---------------------------------------- define <2 x i8> @mul_negpow2_commute_vec(<2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %m = mul <2 x i8> %x, { 248, 248 } %a = add <2 x i8> %y, %m ret <2 x i8> %a } => define <2 x i8> @mul_negpow2_commute_vec(<2 x i8> %x, <2 x i8> %p) { #0: %y = mul <2 x i8> %p, %p %#1 = shl <2 x i8> %x, { 3, 3 } %a = sub <2 x i8> %y, %#1 ret <2 x i8> %a } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 724. PassManager<Function> : Skipping NOP -- 725. PassManager<Function> : Skipping NOP -- 726. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @mul_negpow2_use(i8 %x) { #0: %m = mul i8 %x, 254 call void @use(i8 %m) %a = add i8 %m, 42 ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 727. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @mul_negpow2_use(i8 %x) { #0: %m = mul i8 %x, 254 call void @use(i8 %m) %a = add i8 %m, 42 ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 728. PassManager<Function> : Skipping NOP -- 729. PassManager<Function> : Skipping NOP -- 730. InstCombinePass ---------------------------------------- define i8 @mul_not_negpow2(i8 %x) { #0: %m = mul i8 %x, 253 %a = add i8 %m, 42 ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 731. InstCombinePass ---------------------------------------- define i8 @mul_not_negpow2(i8 %x) { #0: %m = mul i8 %x, 253 %a = add i8 %m, 42 ret i8 %a } Transformation seems to be correct! (syntactically equal) -- 732. PassManager<Function> : Skipping NOP -- 733. PassManager<Function> : Skipping NOP -- 734. InstCombinePass ---------------------------------------- define i16 @add_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 735. InstCombinePass ---------------------------------------- define i16 @add_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } => define i16 @add_sub_zext(i8 %x, i8 %y) { #0: %#1 = zext i8 %y to i16 ret i16 %#1 } Transformation seems to be correct! -- 736. PassManager<Function> : Skipping NOP -- 737. PassManager<Function> : Skipping NOP -- 738. InstCombinePass ---------------------------------------- define i16 @add_commute_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 739. InstCombinePass ---------------------------------------- define i16 @add_commute_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } => define i16 @add_commute_sub_zext(i8 %x, i8 %y) { #0: %#1 = zext i8 %y to i16 ret i16 %#1 } Transformation seems to be correct! -- 740. PassManager<Function> : Skipping NOP -- 741. PassManager<Function> : Skipping NOP -- 742. InstCombinePass ---------------------------------------- define <2 x i8> @add_sub_2xi5_zext(<2 x i5> %x, <2 x i5> %y) { #0: %#1 = sub nuw <2 x i5> %y, %x %#2 = zext <2 x i5> %#1 to <2 x i8> %#3 = zext <2 x i5> %x to <2 x i8> %#4 = add <2 x i8> %#3, %#2 ret <2 x i8> %#4 } Transformation seems to be correct! (syntactically equal) -- 743. InstCombinePass ---------------------------------------- define <2 x i8> @add_sub_2xi5_zext(<2 x i5> %x, <2 x i5> %y) { #0: %#1 = sub nuw <2 x i5> %y, %x %#2 = zext <2 x i5> %#1 to <2 x i8> %#3 = zext <2 x i5> %x to <2 x i8> %#4 = add <2 x i8> %#3, %#2 ret <2 x i8> %#4 } => define <2 x i8> @add_sub_2xi5_zext(<2 x i5> %x, <2 x i5> %y) { #0: %#1 = zext <2 x i5> %y to <2 x i8> ret <2 x i8> %#1 } Transformation seems to be correct! -- 744. PassManager<Function> : Skipping NOP -- 745. PassManager<Function> : Skipping NOP -- 746. InstCombinePass ---------------------------------------- define i3 @add_commute_sub_i2_zext_i3(i2 %x, i2 %y) { #0: %#1 = sub nuw i2 %y, %x %#2 = zext i2 %#1 to i3 %#3 = zext i2 %x to i3 %#4 = add i3 %#3, %#2 ret i3 %#4 } Transformation seems to be correct! (syntactically equal) -- 747. InstCombinePass ---------------------------------------- define i3 @add_commute_sub_i2_zext_i3(i2 %x, i2 %y) { #0: %#1 = sub nuw i2 %y, %x %#2 = zext i2 %#1 to i3 %#3 = zext i2 %x to i3 %#4 = add i3 %#3, %#2 ret i3 %#4 } => define i3 @add_commute_sub_i2_zext_i3(i2 %x, i2 %y) { #0: %#1 = zext i2 %y to i3 ret i3 %#1 } Transformation seems to be correct! -- 748. PassManager<Function> : Skipping NOP -- 749. PassManager<Function> : Skipping NOP -- 750. InstCombinePass ---------------------------------------- declare void @use(i8) define i16 @add_sub_use_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x call void @use(i8 %#1) %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 751. InstCombinePass ---------------------------------------- declare void @use(i8) define i16 @add_sub_use_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x call void @use(i8 %#1) %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } => declare void @use(i8) define i16 @add_sub_use_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %y, %x call void @use(i8 %#1) %#2 = zext i8 %y to i16 ret i16 %#2 } Transformation seems to be correct! -- 752. PassManager<Function> : Skipping NOP -- 753. PassManager<Function> : Skipping NOP -- 754. InstCombinePass ---------------------------------------- define i16 @add_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 755. InstCombinePass ---------------------------------------- define i16 @add_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } => define i16 @add_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub nuw i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add nsw nuw i16 %#2, %#3 ret i16 %#4 } Transformation seems to be correct! -- 756. PassManager<Function> : Skipping NOP -- 757. PassManager<Function> : Skipping NOP -- 758. InstCombinePass ---------------------------------------- define i16 @add_no_nuw_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 759. InstCombinePass ---------------------------------------- define i16 @add_no_nuw_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } => define i16 @add_no_nuw_sub_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %y, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add nsw nuw i16 %#3, %#2 ret i16 %#4 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 760. PassManager<Function> : Skipping NOP -- 761. PassManager<Function> : Skipping NOP -- 762. InstCombinePass ---------------------------------------- define i16 @add_no_nuw_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 763. InstCombinePass ---------------------------------------- define i16 @add_no_nuw_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#3, %#2 ret i16 %#4 } => define i16 @add_no_nuw_sub_commute_zext(i8 %x, i8 %y) { #0: %#1 = sub i8 %x, %y %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add nsw nuw i16 %#3, %#2 ret i16 %#4 } Transformation doesn't verify! (not unsound) ERROR: Timeout -- 764. PassManager<Function> : Skipping NOP -- 765. PassManager<Function> : Skipping NOP -- 766. InstCombinePass ---------------------------------------- define i16 @add_sub_zext_constant(i8 %x) { #0: %#1 = sub nuw i8 254, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } Transformation seems to be correct! (syntactically equal) -- 767. InstCombinePass ---------------------------------------- define i16 @add_sub_zext_constant(i8 %x) { #0: %#1 = sub nuw i8 254, %x %#2 = zext i8 %#1 to i16 %#3 = zext i8 %x to i16 %#4 = add i16 %#2, %#3 ret i16 %#4 } => define i16 @add_sub_zext_constant(i8 %x) { #0: ret i16 254 } Transformation seems to be correct! -- 768. PassManager<Function> : Skipping NOP -- 769. PassManager<Function> : Skipping NOP ERROR: Unsupported type: <vscale x 1 x i32> -- 770. InstCombinePass ERROR: Unsupported type: <vscale x 1 x i32> -- 771. InstCombinePass ERROR: Unsupported type: <vscale x 1 x i32> -- 772. PassManager<Function> : Skipping NOP ERROR: Unsupported type: <vscale x 1 x i32> -- 773. PassManager<Function> : Skipping NOP -- 774. InstCombinePass ---------------------------------------- define i5 @zext_zext_not(i3 %x) { #0: %zx = zext i3 %x to i5 %notx = xor i3 %x, 7 %znotx = zext i3 %notx to i5 %r = add i5 %zx, %znotx ret i5 %r } Transformation seems to be correct! (syntactically equal) -- 775. InstCombinePass ---------------------------------------- define i5 @zext_zext_not(i3 %x) { #0: %zx = zext i3 %x to i5 %notx = xor i3 %x, 7 %znotx = zext i3 %notx to i5 %r = add i5 %zx, %znotx ret i5 %r } => define i5 @zext_zext_not(i3 %x) { #0: ret i5 7 } Transformation seems to be correct! -- 776. PassManager<Function> : Skipping NOP -- 777. PassManager<Function> : Skipping NOP -- 778. InstCombinePass ---------------------------------------- define <2 x i5> @zext_zext_not_commute(<2 x i3> %x) { #0: %zx = zext <2 x i3> %x to <2 x i5> %notx = xor <2 x i3> %x, { 7, poison } %znotx = zext <2 x i3> %notx to <2 x i5> %r = add <2 x i5> %znotx, %zx ret <2 x i5> %r } Transformation seems to be correct! (syntactically equal) -- 779. InstCombinePass ---------------------------------------- define <2 x i5> @zext_zext_not_commute(<2 x i3> %x) { #0: %zx = zext <2 x i3> %x to <2 x i5> %notx = xor <2 x i3> %x, { 7, poison } %znotx = zext <2 x i3> %notx to <2 x i5> %r = add <2 x i5> %znotx, %zx ret <2 x i5> %r } => define <2 x i5> @zext_zext_not_commute(<2 x i3> %x) { #0: ret <2 x i5> { 7, 7 } } Transformation seems to be correct! -- 780. PassManager<Function> : Skipping NOP -- 781. PassManager<Function> : Skipping NOP -- 782. InstCombinePass ---------------------------------------- define i9 @sext_sext_not(i3 %x) { #0: %sx = sext i3 %x to i9 %notx = xor i3 %x, 7 %snotx = sext i3 %notx to i9 %r = add i9 %sx, %snotx ret i9 %r } Transformation seems to be correct! (syntactically equal) -- 783. InstCombinePass ---------------------------------------- define i9 @sext_sext_not(i3 %x) { #0: %sx = sext i3 %x to i9 %notx = xor i3 %x, 7 %snotx = sext i3 %notx to i9 %r = add i9 %sx, %snotx ret i9 %r } => define i9 @sext_sext_not(i3 %x) { #0: ret i9 511 } Transformation seems to be correct! -- 784. PassManager<Function> : Skipping NOP -- 785. PassManager<Function> : Skipping NOP -- 786. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @sext_sext_not_commute(i3 %x) { #0: %sx = sext i3 %x to i8 call void @use(i8 %sx) %notx = xor i3 %x, 7 %snotx = sext i3 %notx to i8 %r = add i8 %snotx, %sx ret i8 %r } Transformation seems to be correct! (syntactically equal) -- 787. InstCombinePass ---------------------------------------- declare void @use(i8) define i8 @sext_sext_not_commute(i3 %x) { #0: %sx = sext i3 %x to i8 call void @use(i8 %sx) %notx = xor i3 %x, 7 %snotx = sext i3 %notx to i8 %r = add i8 %snotx, %sx ret i8 %r } => declare void @use(i8) define i8 @sext_sext_not_commute(i3 %x) { #0: %sx = sext i3 %x to i8 call void @use(i8 %sx) ret i8 255 } Transformation seems to be correct! -- 788. PassManager<Function> : Skipping NOP -- 789. PassManager<Function> : Skipping NOP -- 790. InstCombinePass ---------------------------------------- define i5 @zext_sext_not(i4 %x) { #0: %zx = zext i4 %x to i5 %notx = xor i4 %x, 15 %snotx = sext i4 %notx to i5 %r = add i5 %zx, %snotx ret i5 %r } Transformation seems to be correct! (syntactically equal) -- 791. InstCombinePass ---------------------------------------- define i5 @zext_sext_not(i4 %x) { #0: %zx = zext i4 %x to i5 %notx = xor i4 %x, 15 %snotx = sext i4 %notx to i5 %r = add i5 %zx, %snotx ret i5 %r } => define i5 @zext_sext_not(i4 %x) { #0: %zx = zext i4 %x to i5 %notx = xor i4 %x, 15 %snotx = sext i4 %notx to i5 %r = or disjoint i5 %zx, %snotx ret i5 %r } Transformation doesn't verify! (unsound) ERROR: Target is more poisonous than source Example: i4 %x = undef Source: i5 %zx = #x00 (0) [based on undef value] i4 %notx = #xf (15, -1) [based on undef value] i5 %snotx = #x1f (31, -1) i5 %r = #x1f (31, -1) Target: i5 %zx = #x0f (15) i4 %notx = #xf (15, -1) i5 %snotx = #x1f (31, -1) i5 %r = poison Source value: #x1f (31, -1) Target value: 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' Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_ondxHkuL_MHwa.bc" ------------------- SMT STATS ------------------- Num queries: 953 Num invalid: 0 Num skips: 0 Num trivial: 523 (35.4%) Num timeout: 36 (3.8%) Num errors: 0 (0.0%) Num SAT: 508 (53.3%) Num UNSAT: 409 (42.9%) Alive2: Transform doesn't verify; aborting!
RUN: at line 2: /home/nlopes/alive2/build/opt-alive.sh < /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/add.ll -passes=instcombine -S | /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/add.ll + /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/add.ll + /home/nlopes/alive2/build/opt-alive.sh -passes=instcombine -S FileCheck error: '<stdin>' is empty. FileCheck command line: /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/InstCombine/add.ll
NOTE: This test would pass if undef didn't exist!