diff options
Diffstat (limited to 'llvm/test/Transforms/InstCombine')
135 files changed, 5961 insertions, 0 deletions
diff --git a/llvm/test/Transforms/InstCombine/.cvsignore b/llvm/test/Transforms/InstCombine/.cvsignore new file mode 100644 index 00000000000..7f2443f2f31 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/.cvsignore @@ -0,0 +1,3 @@ +Output +*.log +*.sum diff --git a/llvm/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll b/llvm/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll new file mode 100644 index 00000000000..dd683a3d99a --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-03-11-InstCombineHang.ll @@ -0,0 +1,11 @@ +; This testcase causes instcombine to hang. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine + +implementation + +void "test"(int %X) +begin + %reg117 = add int %X, 0 + ret void +end diff --git a/llvm/test/Transforms/InstCombine/2002-05-14-SubFailure.ll b/llvm/test/Transforms/InstCombine/2002-05-14-SubFailure.ll new file mode 100644 index 00000000000..1228fd0acae --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-05-14-SubFailure.ll @@ -0,0 +1,12 @@ +; Instcombine was missing a test that caused it to make illegal transformations +; sometimes. In this case, it transforms the sub into an add: +; RUN: echo foo +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep add +; + + +int "test"(int %i, int %j) { + %A = mul int %i, %j + %B = sub int 2, %A + ret int %B +} diff --git a/llvm/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll b/llvm/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll new file mode 100644 index 00000000000..9c278edc8dc --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-05-14-TouchDeletedInst.ll @@ -0,0 +1,509 @@ +; This testcase, obviously distilled from a large program (bzip2 from Specint2000) +; caused instcombine to fail because it got the same instruction on it's worklist +; more than once (which is ok), but then deleted the instruction. Since the inst +; stayed on the worklist, as soon as it came back up to be processed, bad things +; happened, and opt asserted. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine +; + +%.LC0 = internal global [21 x sbyte] c"hbMakeCodeLengths(1)\00" ; <[21 x sbyte]*> [#uses=1] +%.LC1 = internal global [21 x sbyte] c"hbMakeCodeLengths(2)\00" ; <[21 x sbyte]*> [#uses=1] + +implementation ; Functions: + +void %hbMakeCodeLengths(ubyte* %len, int* %freq, int %alphaSize, int %maxLen) { +bb0: ;[#uses=0] + %len = alloca ubyte* ; <ubyte**> [#uses=2] + store ubyte* %len, ubyte** %len + %freq = alloca int* ; <int**> [#uses=2] + store int* %freq, int** %freq + %alphaSize = alloca int ; <int*> [#uses=2] + store int %alphaSize, int* %alphaSize + %maxLen = alloca int ; <int*> [#uses=2] + store int %maxLen, int* %maxLen + %heap = alloca int, uint 260 ; <int*> [#uses=27] + %weight = alloca int, uint 516 ; <int*> [#uses=18] + %parent = alloca int, uint 516 ; <int*> [#uses=7] + br label %bb1 + +bb1: ;[#uses=2] + %reg107 = load ubyte** %len ; <ubyte*> [#uses=1] + %reg108 = load int** %freq ; <int*> [#uses=1] + %reg109 = load int* %alphaSize ; <int> [#uses=10] + %reg110 = load int* %maxLen ; <int> [#uses=1] + %cond747 = setge int 0, %reg109 ; <bool> [#uses=1] + br bool %cond747, label %bb6, label %bb2 + +bb2: ;[#uses=2] + %reg591 = phi int [ %reg594, %bb5 ], [ 0, %bb1 ] ; <int> [#uses=3] + %reg591-idxcast1 = cast int %reg591 to uint ; <uint> [#uses=1] + %reg591-idxcast1-offset = add uint %reg591-idxcast1, 1 ; <uint> [#uses=1] + %reg591-idxcast1-offset = cast uint %reg591-idxcast1-offset to long ; <long> [#uses=1] + %reg126 = getelementptr int* %weight, long %reg591-idxcast1-offset ; <int*> [#uses=1] + %reg591-idxcast = cast int %reg591 to long ; <long> [#uses=1] + %reg132 = getelementptr int* %reg108, long %reg591-idxcast ; <int*> [#uses=1] + %reg133 = load int* %reg132 ; <int> [#uses=2] + %cond748 = seteq int %reg133, 0 ; <bool> [#uses=1] + br bool %cond748, label %bb4, label %bb3 + +bb3: ;[#uses=2] + %reg127 = shl int %reg133, ubyte 8 ; <int> [#uses=1] + br label %bb5 + +bb4: ;[#uses=2] + br label %bb5 + +bb5: ;[#uses=3] + %reg593 = phi int [ 256, %bb4 ], [ %reg127, %bb3 ] ; <int> [#uses=1] + store int %reg593, int* %reg126 + %reg594 = add int %reg591, 1 ; <int> [#uses=2] + %cond749 = setlt int %reg594, %reg109 ; <bool> [#uses=1] + br bool %cond749, label %bb2, label %bb6 + +bb6: ;[#uses=6] + store int 0, int* %heap + store int 0, int* %weight + store int -2, int* %parent + %cond750 = setgt int 1, %reg109 ; <bool> [#uses=1] + br bool %cond750, label %bb11, label %bb7 + +bb7: ;[#uses=3] + %reg597 = phi uint [ %reg598, %bb10 ], [ 0, %bb6 ] ; <uint> [#uses=5] + %reg597-casted = cast uint %reg597 to int ; <int> [#uses=1] + %reg596 = add int %reg597-casted, 1 ; <int> [#uses=3] + %reg597-offset = add uint %reg597, 1 ; <uint> [#uses=1] + %reg597-offset = cast uint %reg597-offset to long ; <long> [#uses=1] + %reg149 = getelementptr int* %parent, long %reg597-offset ; <int*> [#uses=1] + store int -1, int* %reg149 + %reg598 = add uint %reg597, 1 ; <uint> [#uses=3] + %reg597-offset1 = add uint %reg597, 1 ; <uint> [#uses=1] + %reg597-offset1 = cast uint %reg597-offset1 to long ; <long> [#uses=1] + %reg157 = getelementptr int* %heap, long %reg597-offset1 ; <int*> [#uses=1] + store int %reg596, int* %reg157 + br label %bb9 + +bb8: ;[#uses=2] + %reg599 = cast uint %reg599 to long ; <long> [#uses=1] + %reg198 = getelementptr int* %heap, long %reg599 ; <int*> [#uses=1] + store int %reg182, int* %reg198 + %cast938 = cast int %reg174 to uint ; <uint> [#uses=1] + br label %bb9 + +bb9: ;[#uses=2] + %reg599 = phi uint [ %cast938, %bb8 ], [ %reg598, %bb7 ] ; <uint> [#uses=3] + %cast807 = cast uint %reg599 to int ; <int> [#uses=1] + %reg597-offset2 = add uint %reg597, 1 ; <uint> [#uses=1] + %reg597-offset2 = cast uint %reg597-offset2 to long ; <long> [#uses=1] + %reg173 = getelementptr int* %weight, long %reg597-offset2 ; <int*> [#uses=1] + %reg174 = shr int %cast807, ubyte 1 ; <int> [#uses=2] + %reg174-idxcast = cast int %reg174 to uint ; <uint> [#uses=1] + cast uint %reg174-idxcast to long ; <long>:0 [#uses=1] + %reg181 = getelementptr int* %heap, long %0 ; <int*> [#uses=1] + %reg182 = load int* %reg181 ; <int> [#uses=2] + %reg182-idxcast = cast int %reg182 to uint ; <uint> [#uses=1] + cast uint %reg182-idxcast to long ; <long>:1 [#uses=1] + %reg189 = getelementptr int* %weight, long %1 ; <int*> [#uses=1] + %reg190 = load int* %reg173 ; <int> [#uses=1] + %reg191 = load int* %reg189 ; <int> [#uses=1] + %cond751 = setlt int %reg190, %reg191 ; <bool> [#uses=1] + br bool %cond751, label %bb8, label %bb10 + +bb10: ;[#uses=3] + cast uint %reg599 to long ; <long>:2 [#uses=1] + %reg214 = getelementptr int* %heap, long %2 ; <int*> [#uses=1] + store int %reg596, int* %reg214 + %reg601 = add int %reg596, 1 ; <int> [#uses=1] + %cond752 = setle int %reg601, %reg109 ; <bool> [#uses=1] + br bool %cond752, label %bb7, label %bb11 + +bb11: ;[#uses=2] + %reg602 = phi uint [ %reg598, %bb10 ], [ 0, %bb6 ] ; <uint> [#uses=3] + %cast819 = cast uint %reg602 to int ; <int> [#uses=1] + %cast818 = cast uint %reg602 to int ; <int> [#uses=1] + %cond753 = setle int %cast818, 259 ; <bool> [#uses=1] + br bool %cond753, label %bb13, label %bb12 + +bb12: ;[#uses=1] + cast uint 0 to long ; <long>:3 [#uses=1] + cast uint 0 to long ; <long>:4 [#uses=1] + %cast784 = getelementptr [21 x sbyte]* %.LC0, long %3, long %4 ; <sbyte*> [#uses=1] + call void %panic( sbyte* %cast784 ) + br label %bb13 + +bb13: ;[#uses=4] + %cond754 = setle int %cast819, 1 ; <bool> [#uses=1] + %cast918 = cast int %reg109 to uint ; <uint> [#uses=1] + %cast940 = cast uint %reg602 to int ; <int> [#uses=1] + %cast942 = cast int %reg109 to uint ; <uint> [#uses=1] + br bool %cond754, label %bb32, label %bb14 + +bb14: ;[#uses=5] + %cann-indvar1 = phi uint [ 0, %bb13 ], [ %add1-indvar1, %bb31 ] ; <uint> [#uses=3] + %cann-indvar1-casted = cast uint %cann-indvar1 to int ; <int> [#uses=1] + %reg603-scale = mul int %cann-indvar1-casted, -1 ; <int> [#uses=1] + %reg603 = add int %reg603-scale, %cast940 ; <int> [#uses=4] + %reg604 = add uint %cann-indvar1, %cast942 ; <uint> [#uses=4] + %add1-indvar1 = add uint %cann-indvar1, 1 ; <uint> [#uses=1] + cast uint 1 to long ; <long>:5 [#uses=1] + %reg7551 = getelementptr int* %heap, long %5 ; <int*> [#uses=1] + %reg113 = load int* %reg7551 ; <int> [#uses=2] + %reg603-idxcast = cast int %reg603 to uint ; <uint> [#uses=1] + cast uint %reg603-idxcast to long ; <long>:6 [#uses=1] + %reg222 = getelementptr int* %heap, long %6 ; <int*> [#uses=1] + %reg223 = load int* %reg222 ; <int> [#uses=1] + cast uint 1 to long ; <long>:7 [#uses=1] + %reg7561 = getelementptr int* %heap, long %7 ; <int*> [#uses=1] + store int %reg223, int* %reg7561 + %reg605 = add int %reg603, -1 ; <int> [#uses=4] + cast uint 1 to long ; <long>:8 [#uses=1] + %reg757 = getelementptr int* %heap, long %8 ; <int*> [#uses=1] + %reg226 = load int* %reg757 ; <int> [#uses=2] + %cond758 = setgt int 2, %reg605 ; <bool> [#uses=1] + br bool %cond758, label %bb20, label %bb15 + +bb15: ;[#uses=3] + %reg606 = phi int [ %reg611, %bb19 ], [ 2, %bb14 ] ; <int> [#uses=6] + %reg607 = phi int [ %reg609, %bb19 ], [ 1, %bb14 ] ; <int> [#uses=2] + %cond759 = setge int %reg606, %reg605 ; <bool> [#uses=1] + br bool %cond759, label %bb18, label %bb16 + +bb16: ;[#uses=2] + %reg606-idxcast = cast int %reg606 to uint ; <uint> [#uses=1] + %reg606-idxcast-offset = add uint %reg606-idxcast, 1 ; <uint> [#uses=1] + cast uint %reg606-idxcast-offset to long ; <long>:9 [#uses=1] + %reg241 = getelementptr int* %heap, long %9 ; <int*> [#uses=1] + %reg242 = load int* %reg241 ; <int> [#uses=1] + %reg242-idxcast = cast int %reg242 to uint ; <uint> [#uses=1] + cast uint %reg242-idxcast to long ; <long>:10 [#uses=1] + %reg249 = getelementptr int* %weight, long %10 ; <int*> [#uses=1] + %reg606-idxcast1 = cast int %reg606 to uint ; <uint> [#uses=1] + cast uint %reg606-idxcast1 to long ; <long>:11 [#uses=1] + %reg256 = getelementptr int* %heap, long %11 ; <int*> [#uses=1] + %reg257 = load int* %reg256 ; <int> [#uses=1] + %reg257-idxcast = cast int %reg257 to uint ; <uint> [#uses=1] + cast uint %reg257-idxcast to long ; <long>:12 [#uses=1] + %reg264 = getelementptr int* %weight, long %12 ; <int*> [#uses=1] + %reg265 = load int* %reg249 ; <int> [#uses=1] + %reg266 = load int* %reg264 ; <int> [#uses=1] + %cond760 = setge int %reg265, %reg266 ; <bool> [#uses=1] + br bool %cond760, label %bb18, label %bb17 + +bb17: ;[#uses=2] + %reg608 = add int %reg606, 1 ; <int> [#uses=1] + br label %bb18 + +bb18: ;[#uses=4] + %reg609 = phi int [ %reg608, %bb17 ], [ %reg606, %bb16 ], [ %reg606, %bb15 ] ; <int> [#uses=4] + %reg226-idxcast = cast int %reg226 to uint ; <uint> [#uses=1] + cast uint %reg226-idxcast to long ; <long>:13 [#uses=1] + %reg273 = getelementptr int* %weight, long %13 ; <int*> [#uses=1] + %reg609-idxcast = cast int %reg609 to uint ; <uint> [#uses=1] + cast uint %reg609-idxcast to long ; <long>:14 [#uses=1] + %reg280 = getelementptr int* %heap, long %14 ; <int*> [#uses=1] + %reg281 = load int* %reg280 ; <int> [#uses=2] + %reg281-idxcast = cast int %reg281 to uint ; <uint> [#uses=1] + cast uint %reg281-idxcast to long ; <long>:15 [#uses=1] + %reg288 = getelementptr int* %weight, long %15 ; <int*> [#uses=1] + %reg289 = load int* %reg273 ; <int> [#uses=1] + %reg290 = load int* %reg288 ; <int> [#uses=1] + %cond761 = setlt int %reg289, %reg290 ; <bool> [#uses=1] + br bool %cond761, label %bb20, label %bb19 + +bb19: ;[#uses=4] + %reg607-idxcast = cast int %reg607 to uint ; <uint> [#uses=1] + cast uint %reg607-idxcast to long ; <long>:16 [#uses=1] + %reg297 = getelementptr int* %heap, long %16 ; <int*> [#uses=1] + store int %reg281, int* %reg297 + %reg611 = shl int %reg609, ubyte 1 ; <int> [#uses=2] + %cond762 = setle int %reg611, %reg605 ; <bool> [#uses=1] + br bool %cond762, label %bb15, label %bb20 + +bb20: ;[#uses=6] + %reg612 = phi int [ %reg609, %bb19 ], [ %reg607, %bb18 ], [ 1, %bb14 ] ; <int> [#uses=1] + %reg612-idxcast = cast int %reg612 to uint ; <uint> [#uses=1] + cast uint %reg612-idxcast to long ; <long>:17 [#uses=1] + %reg312 = getelementptr int* %heap, long %17 ; <int*> [#uses=1] + store int %reg226, int* %reg312 + cast uint 1 to long ; <long>:18 [#uses=1] + %reg7631 = getelementptr int* %heap, long %18 ; <int*> [#uses=1] + %reg114 = load int* %reg7631 ; <int> [#uses=2] + %reg603-idxcast1 = cast int %reg603 to uint ; <uint> [#uses=1] + %reg603-idxcast1-offset = add uint %reg603-idxcast1, 1073741823 ; <uint> [#uses=1] + cast uint %reg603-idxcast1-offset to long ; <long>:19 [#uses=1] + %reg319 = getelementptr int* %heap, long %19 ; <int*> [#uses=1] + %reg320 = load int* %reg319 ; <int> [#uses=1] + cast uint 1 to long ; <long>:20 [#uses=1] + %reg7641 = getelementptr int* %heap, long %20 ; <int*> [#uses=1] + store int %reg320, int* %reg7641 + %reg613 = add int %reg605, -1 ; <int> [#uses=4] + cast uint 1 to long ; <long>:21 [#uses=1] + %reg765 = getelementptr int* %heap, long %21 ; <int*> [#uses=1] + %reg323 = load int* %reg765 ; <int> [#uses=2] + %cond766 = setgt int 2, %reg613 ; <bool> [#uses=1] + br bool %cond766, label %bb26, label %bb21 + +bb21: ;[#uses=3] + %reg614 = phi int [ %reg619, %bb25 ], [ 2, %bb20 ] ; <int> [#uses=6] + %reg615 = phi int [ %reg617, %bb25 ], [ 1, %bb20 ] ; <int> [#uses=2] + %cond767 = setge int %reg614, %reg613 ; <bool> [#uses=1] + br bool %cond767, label %bb24, label %bb22 + +bb22: ;[#uses=2] + %reg614-idxcast = cast int %reg614 to uint ; <uint> [#uses=1] + %reg614-idxcast-offset = add uint %reg614-idxcast, 1 ; <uint> [#uses=1] + cast uint %reg614-idxcast-offset to long ; <long>:22 [#uses=1] + %reg338 = getelementptr int* %heap, long %22 ; <int*> [#uses=1] + %reg339 = load int* %reg338 ; <int> [#uses=1] + %reg339-idxcast = cast int %reg339 to uint ; <uint> [#uses=1] + cast uint %reg339-idxcast to long ; <long>:23 [#uses=1] + %reg346 = getelementptr int* %weight, long %23 ; <int*> [#uses=1] + %reg614-idxcast1 = cast int %reg614 to uint ; <uint> [#uses=1] + cast uint %reg614-idxcast1 to long ; <long>:24 [#uses=1] + %reg353 = getelementptr int* %heap, long %24 ; <int*> [#uses=1] + %reg354 = load int* %reg353 ; <int> [#uses=1] + %reg354-idxcast = cast int %reg354 to uint ; <uint> [#uses=1] + cast uint %reg354-idxcast to long ; <long>:25 [#uses=1] + %reg361 = getelementptr int* %weight, long %25 ; <int*> [#uses=1] + %reg362 = load int* %reg346 ; <int> [#uses=1] + %reg363 = load int* %reg361 ; <int> [#uses=1] + %cond768 = setge int %reg362, %reg363 ; <bool> [#uses=1] + br bool %cond768, label %bb24, label %bb23 + +bb23: ;[#uses=2] + %reg616 = add int %reg614, 1 ; <int> [#uses=1] + br label %bb24 + +bb24: ;[#uses=4] + %reg617 = phi int [ %reg616, %bb23 ], [ %reg614, %bb22 ], [ %reg614, %bb21 ] ; <int> [#uses=4] + %reg323-idxcast = cast int %reg323 to uint ; <uint> [#uses=1] + cast uint %reg323-idxcast to long ; <long>:26 [#uses=1] + %reg370 = getelementptr int* %weight, long %26 ; <int*> [#uses=1] + %reg617-idxcast = cast int %reg617 to uint ; <uint> [#uses=1] + cast uint %reg617-idxcast to long ; <long>:27 [#uses=1] + %reg377 = getelementptr int* %heap, long %27 ; <int*> [#uses=1] + %reg378 = load int* %reg377 ; <int> [#uses=2] + %reg378-idxcast = cast int %reg378 to uint ; <uint> [#uses=1] + cast uint %reg378-idxcast to long ; <long>:28 [#uses=1] + %reg385 = getelementptr int* %weight, long %28 ; <int*> [#uses=1] + %reg386 = load int* %reg370 ; <int> [#uses=1] + %reg387 = load int* %reg385 ; <int> [#uses=1] + %cond769 = setlt int %reg386, %reg387 ; <bool> [#uses=1] + br bool %cond769, label %bb26, label %bb25 + +bb25: ;[#uses=4] + %reg615-idxcast = cast int %reg615 to uint ; <uint> [#uses=1] + cast uint %reg615-idxcast to long ; <long>:29 [#uses=1] + %reg394 = getelementptr int* %heap, long %29 ; <int*> [#uses=1] + store int %reg378, int* %reg394 + %reg619 = shl int %reg617, ubyte 1 ; <int> [#uses=2] + %cond770 = setle int %reg619, %reg613 ; <bool> [#uses=1] + br bool %cond770, label %bb21, label %bb26 + +bb26: ;[#uses=4] + %reg620 = phi int [ %reg617, %bb25 ], [ %reg615, %bb24 ], [ 1, %bb20 ] ; <int> [#uses=1] + %reg620-idxcast = cast int %reg620 to uint ; <uint> [#uses=1] + cast uint %reg620-idxcast to long ; <long>:30 [#uses=1] + %reg409 = getelementptr int* %heap, long %30 ; <int*> [#uses=1] + store int %reg323, int* %reg409 + %reg621 = add uint %reg604, 1 ; <uint> [#uses=5] + %reg113-idxcast = cast int %reg113 to uint ; <uint> [#uses=1] + cast uint %reg113-idxcast to long ; <long>:31 [#uses=1] + %reg416 = getelementptr int* %parent, long %31 ; <int*> [#uses=1] + %reg114-idxcast = cast int %reg114 to uint ; <uint> [#uses=1] + cast uint %reg114-idxcast to long ; <long>:32 [#uses=1] + %reg423 = getelementptr int* %parent, long %32 ; <int*> [#uses=1] + %cast889 = cast uint %reg621 to int ; <int> [#uses=1] + store int %cast889, int* %reg423 + %cast890 = cast uint %reg621 to int ; <int> [#uses=1] + store int %cast890, int* %reg416 + %reg604-offset = add uint %reg604, 1 ; <uint> [#uses=1] + cast uint %reg604-offset to long ; <long>:33 [#uses=1] + %reg431 = getelementptr int* %weight, long %33 ; <int*> [#uses=1] + %reg113-idxcast2 = cast int %reg113 to uint ; <uint> [#uses=1] + cast uint %reg113-idxcast2 to long ; <long>:34 [#uses=1] + %reg4381 = getelementptr int* %weight, long %34 ; <int*> [#uses=1] + %reg439 = load int* %reg4381 ; <int> [#uses=2] + %reg440 = and int %reg439, -256 ; <int> [#uses=1] + %reg114-idxcast2 = cast int %reg114 to uint ; <uint> [#uses=1] + cast uint %reg114-idxcast2 to long ; <long>:35 [#uses=1] + %reg4471 = getelementptr int* %weight, long %35 ; <int*> [#uses=1] + %reg448 = load int* %reg4471 ; <int> [#uses=2] + %reg449 = and int %reg448, -256 ; <int> [#uses=1] + %reg450 = add int %reg440, %reg449 ; <int> [#uses=1] + %reg460 = and int %reg439, 255 ; <int> [#uses=2] + %reg451 = and int %reg448, 255 ; <int> [#uses=2] + %cond771 = setge int %reg451, %reg460 ; <bool> [#uses=1] + br bool %cond771, label %bb28, label %bb27 + +bb27: ;[#uses=2] + br label %bb28 + +bb28: ;[#uses=3] + %reg623 = phi int [ %reg460, %bb27 ], [ %reg451, %bb26 ] ; <int> [#uses=1] + %reg469 = add int %reg623, 1 ; <int> [#uses=1] + %reg470 = or int %reg450, %reg469 ; <int> [#uses=1] + store int %reg470, int* %reg431 + %reg604-offset1 = add uint %reg604, 1 ; <uint> [#uses=1] + cast uint %reg604-offset1 to long ; <long>:36 [#uses=1] + %reg4771 = getelementptr int* %parent, long %36 ; <int*> [#uses=1] + store int -1, int* %reg4771 + %reg624 = add int %reg613, 1 ; <int> [#uses=2] + %reg603-idxcast2 = cast int %reg603 to uint ; <uint> [#uses=1] + %reg603-idxcast2-offset = add uint %reg603-idxcast2, 1073741823 ; <uint> [#uses=1] + cast uint %reg603-idxcast2-offset to long ; <long>:37 [#uses=1] + %reg485 = getelementptr int* %heap, long %37 ; <int*> [#uses=1] + %cast902 = cast uint %reg621 to int ; <int> [#uses=1] + store int %cast902, int* %reg485 + br label %bb30 + +bb29: ;[#uses=2] + %reg625-idxcast = cast int %reg625 to uint ; <uint> [#uses=1] + cast uint %reg625-idxcast to long ; <long>:38 [#uses=1] + %reg526 = getelementptr int* %heap, long %38 ; <int*> [#uses=1] + store int %reg510, int* %reg526 + br label %bb30 + +bb30: ;[#uses=2] + %reg625 = phi int [ %reg502, %bb29 ], [ %reg624, %bb28 ] ; <int> [#uses=3] + %reg604-offset2 = add uint %reg604, 1 ; <uint> [#uses=1] + cast uint %reg604-offset2 to long ; <long>:39 [#uses=1] + %reg501 = getelementptr int* %weight, long %39 ; <int*> [#uses=1] + %reg502 = shr int %reg625, ubyte 1 ; <int> [#uses=2] + %reg502-idxcast = cast int %reg502 to uint ; <uint> [#uses=1] + cast uint %reg502-idxcast to long ; <long>:40 [#uses=1] + %reg509 = getelementptr int* %heap, long %40 ; <int*> [#uses=1] + %reg510 = load int* %reg509 ; <int> [#uses=2] + %reg510-idxcast = cast int %reg510 to uint ; <uint> [#uses=1] + cast uint %reg510-idxcast to long ; <long>:41 [#uses=1] + %reg517 = getelementptr int* %weight, long %41 ; <int*> [#uses=1] + %reg518 = load int* %reg501 ; <int> [#uses=1] + %reg519 = load int* %reg517 ; <int> [#uses=1] + %cond772 = setlt int %reg518, %reg519 ; <bool> [#uses=1] + br bool %cond772, label %bb29, label %bb31 + +bb31: ;[#uses=3] + %reg625-idxcast1 = cast int %reg625 to uint ; <uint> [#uses=1] + cast uint %reg625-idxcast1 to long ; <long>:42 [#uses=1] + %reg542 = getelementptr int* %heap, long %42 ; <int*> [#uses=1] + %cast916 = cast uint %reg621 to int ; <int> [#uses=1] + store int %cast916, int* %reg542 + %cond773 = setgt int %reg624, 1 ; <bool> [#uses=1] + br bool %cond773, label %bb14, label %bb32 + +bb32: ;[#uses=2] + %reg627 = phi uint [ %reg621, %bb31 ], [ %cast918, %bb13 ] ; <uint> [#uses=1] + %cast919 = cast uint %reg627 to int ; <int> [#uses=1] + %cond774 = setle int %cast919, 515 ; <bool> [#uses=1] + br bool %cond774, label %bb34, label %bb33 + +bb33: ;[#uses=1] + cast uint 0 to long ; <long>:43 [#uses=1] + cast uint 0 to long ; <long>:44 [#uses=1] + %cast785 = getelementptr [21 x sbyte]* %.LC1, long %43, long %44 ; <sbyte*> [#uses=1] + call void %panic( sbyte* %cast785 ) + br label %bb34 + +bb34: ;[#uses=5] + %cond775 = setgt int 1, %reg109 ; <bool> [#uses=1] + br bool %cond775, label %bb40, label %bb35 + +bb35: ;[#uses=5] + %reg629 = phi ubyte [ %reg639, %bb39 ], [ 0, %bb34 ] ; <ubyte> [#uses=1] + %cann-indvar = phi uint [ 0, %bb34 ], [ %add1-indvar, %bb39 ] ; <uint> [#uses=4] + %cann-indvar-casted = cast uint %cann-indvar to int ; <int> [#uses=1] + %reg630 = add int %cann-indvar-casted, 1 ; <int> [#uses=2] + %add1-indvar = add uint %cann-indvar, 1 ; <uint> [#uses=1] + %cann-indvar-offset1 = add uint %cann-indvar, 1 ; <uint> [#uses=1] + cast uint %cann-indvar-offset1 to long ; <long>:45 [#uses=1] + %reg589 = getelementptr int* %parent, long %45 ; <int*> [#uses=1] + %reg590 = load int* %reg589 ; <int> [#uses=1] + %cond776 = setlt int %reg590, 0 ; <bool> [#uses=1] + %parent-idxcast = cast int* %parent to uint ; <uint> [#uses=1] + %cast948 = cast int %reg630 to uint ; <uint> [#uses=1] + br bool %cond776, label %bb37, label %bb36 + +bb36: ;[#uses=5] + %reg632 = phi uint [ %reg634, %bb36 ], [ %cast948, %bb35 ] ; <uint> [#uses=1] + %reg633 = phi uint [ %reg635, %bb36 ], [ 0, %bb35 ] ; <uint> [#uses=3] + %reg633-casted = cast uint %reg633 to sbyte* ; <sbyte*> [#uses=0] + %reg631-scale = mul uint %reg633, 0 ; <uint> [#uses=1] + %reg631-scale = cast uint %reg631-scale to sbyte* ; <sbyte*> [#uses=1] + cast uint %parent-idxcast to long ; <long>:46 [#uses=1] + %reg6311 = getelementptr sbyte* %reg631-scale, long %46 ; <sbyte*> [#uses=2] + %reg632-scale = mul uint %reg632, 4 ; <uint> [#uses=1] + cast uint %reg632-scale to long ; <long>:47 [#uses=1] + %reg5581 = getelementptr sbyte* %reg6311, long %47 ; <sbyte*> [#uses=1] + %cast924 = cast sbyte* %reg5581 to uint* ; <uint*> [#uses=1] + %reg634 = load uint* %cast924 ; <uint> [#uses=2] + %reg635 = add uint %reg633, 1 ; <uint> [#uses=2] + %reg634-scale = mul uint %reg634, 4 ; <uint> [#uses=1] + cast uint %reg634-scale to long ; <long>:48 [#uses=1] + %reg5501 = getelementptr sbyte* %reg6311, long %48 ; <sbyte*> [#uses=1] + %cast925 = cast sbyte* %reg5501 to int* ; <int*> [#uses=1] + %reg551 = load int* %cast925 ; <int> [#uses=1] + %cond777 = setge int %reg551, 0 ; <bool> [#uses=1] + br bool %cond777, label %bb36, label %bb37 + +bb37: ;[#uses=3] + %reg637 = phi uint [ %reg635, %bb36 ], [ 0, %bb35 ] ; <uint> [#uses=2] + %cast928 = cast uint %reg637 to int ; <int> [#uses=1] + %cann-indvar-offset = add uint %cann-indvar, 1 ; <uint> [#uses=1] + cast uint %cann-indvar-offset to long ; <long>:49 [#uses=1] + %reg561 = getelementptr ubyte* %reg107, long %49 ; <ubyte*> [#uses=1] + cast uint 4294967295 to long ; <long>:50 [#uses=1] + %reg778 = getelementptr ubyte* %reg561, long %50 ; <ubyte*> [#uses=1] + %cast788 = cast uint %reg637 to ubyte ; <ubyte> [#uses=1] + store ubyte %cast788, ubyte* %reg778 + %cond779 = setle int %cast928, %reg110 ; <bool> [#uses=1] + br bool %cond779, label %bb39, label %bb38 + +bb38: ;[#uses=2] + br label %bb39 + +bb39: ;[#uses=5] + %reg639 = phi ubyte [ 1, %bb38 ], [ %reg629, %bb37 ] ; <ubyte> [#uses=2] + %reg640 = add int %reg630, 1 ; <int> [#uses=1] + %cond780 = setle int %reg640, %reg109 ; <bool> [#uses=1] + br bool %cond780, label %bb35, label %bb40 + +bb40: ;[#uses=2] + %reg641 = phi ubyte [ %reg639, %bb39 ], [ 0, %bb34 ] ; <ubyte> [#uses=1] + %cond781 = seteq ubyte %reg641, 0 ; <bool> [#uses=1] + br bool %cond781, label %bb44, label %bb41 + +bb41: ;[#uses=2] + %cond782 = setge int 1, %reg109 ; <bool> [#uses=1] + br bool %cond782, label %bb6, label %bb42 + +bb42: ;[#uses=3] + %cann-indvar2 = phi int [ 0, %bb41 ], [ %add1-indvar2, %bb42 ] ; <int> [#uses=3] + %reg643 = add int %cann-indvar2, 1 ; <int> [#uses=1] + %add1-indvar2 = add int %cann-indvar2, 1 ; <int> [#uses=1] + %cann-indvar2-idxcast = cast int %cann-indvar2 to uint ; <uint> [#uses=1] + %cann-indvar2-idxcast-offset = add uint %cann-indvar2-idxcast, 1 ; <uint> [#uses=1] + cast uint %cann-indvar2-idxcast-offset to long ; <long>:51 [#uses=1] + %reg569 = getelementptr int* %weight, long %51 ; <int*> [#uses=2] + %reg570 = load int* %reg569 ; <int> [#uses=2] + %reg644 = shr int %reg570, ubyte 8 ; <int> [#uses=1] + %reg572 = shr int %reg570, ubyte 31 ; <int> [#uses=1] + %cast933 = cast int %reg572 to uint ; <uint> [#uses=1] + %reg573 = shr uint %cast933, ubyte 31 ; <uint> [#uses=1] + %cast934 = cast uint %reg573 to int ; <int> [#uses=1] + %reg574 = add int %reg644, %cast934 ; <int> [#uses=1] + %reg571 = shr int %reg574, ubyte 1 ; <int> [#uses=1] + %reg645 = add int %reg571, 1 ; <int> [#uses=1] + %reg582 = shl int %reg645, ubyte 8 ; <int> [#uses=1] + store int %reg582, int* %reg569 + %reg646 = add int %reg643, 1 ; <int> [#uses=1] + %cond783 = setlt int %reg646, %reg109 ; <bool> [#uses=1] + br bool %cond783, label %bb42, label %bb43 + +bb43: ;[#uses=1] + br label %bb6 + +bb44: ;[#uses=1] + ret void +} + +declare void %panic(sbyte*) diff --git a/llvm/test/Transforms/InstCombine/2002-08-02-CastTest.ll b/llvm/test/Transforms/InstCombine/2002-08-02-CastTest.ll new file mode 100644 index 00000000000..55609f1e7f8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-08-02-CastTest.ll @@ -0,0 +1,11 @@ +; This testcase is incorrectly getting completely eliminated. There should be +; SOME instruction named %c here, even if it's a bitwise and. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep '%c' +; +ulong %test3(ulong %A) { + %c1 = cast ulong %A to ubyte + %c2 = cast ubyte %c1 to ulong + ret ulong %c2 +} + diff --git a/llvm/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll b/llvm/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll new file mode 100644 index 00000000000..69bec19b2be --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-09-17-GetElementPtrCrash.ll @@ -0,0 +1,12 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine + +%bob = type { int } + +int %alias() { + %pbob1 = alloca %bob + %pbob2 = getelementptr %bob* %pbob1 + %pbobel = getelementptr %bob* %pbob2, long 0, uint 0 + %rval = load int* %pbobel + ret int %rval +} + diff --git a/llvm/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll b/llvm/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll new file mode 100644 index 00000000000..6233e5027b6 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2002-12-05-MissedConstProp.ll @@ -0,0 +1,10 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep add + +int %test(int %A) { + %A.neg = sub int 0, %A + %.neg = sub int 0, 1 + %X = add int %.neg, 1 + %Y.neg.ra = add int %A, %X + %r = add int %A.neg, %Y.neg.ra + ret int %r +} diff --git a/llvm/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll b/llvm/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll new file mode 100644 index 00000000000..453258980d5 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-05-26-CastMiscompile.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 4294967295 + +ulong %test(ulong %Val) { + %tmp.3 = cast ulong %Val to uint ; <uint> [#uses=1] + %tmp.8 = cast uint %tmp.3 to ulong ; <ulong> [#uses=1] + ret ulong %tmp.8 +} diff --git a/llvm/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll b/llvm/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll new file mode 100644 index 00000000000..6222169e08d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-05-27-ConstExprCrash.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +%X = global int 5 +long %test() { + %C = add long 1, 2 + %V = add long cast(int* %X to long), %C + ret long %V +} diff --git a/llvm/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll b/llvm/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll new file mode 100644 index 00000000000..ae823d6bf68 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-06-05-BranchInvertInfLoop.ll @@ -0,0 +1,14 @@ +; This testcase causes an infinite loop in the instruction combiner, +; because it things that the constant value is a not expression... and +; constantly inverts the branch back and forth. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +ubyte %test19(bool %c) { + br bool true, label %True, label %False +True: + ret ubyte 1 +False: + ret ubyte 3 +} + diff --git a/llvm/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll b/llvm/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll new file mode 100644 index 00000000000..92a32d5d35b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-06-22-ConstantExprCrash.ll @@ -0,0 +1,12 @@ +; This is a bug in the VMcode library, not instcombine, it's just convenient +; to expose it here. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +%A = global int 1 +%B = global int 2 + +bool %test() { + %C = setlt int* getelementptr (int* %A, long 1), getelementptr (int* %B, long 2) ; Will get promoted to constantexpr + ret bool %C +} diff --git a/llvm/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll b/llvm/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll new file mode 100644 index 00000000000..c9e3b4c5420 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-07-21-ExternalConstant.ll @@ -0,0 +1,46 @@ +; +; Test: ExternalConstant +; +; Description: +; This regression test helps check whether the instruction combining +; optimization pass correctly handles global variables which are marked +; as external and constant. +; +; If a problem occurs, we should die on an assert(). Otherwise, we +; should pass through the optimizer without failure. +; +; Extra code: +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine +; + +target endian = little +target pointersize = 32 +%silly = external constant int ; <int*> [#uses=1] + +implementation ; Functions: + +declare void %bzero(sbyte*, uint) + +declare void %bcopy(sbyte*, sbyte*, uint) + +declare int %bcmp(sbyte*, sbyte*, uint) + +declare int %fputs(sbyte*, sbyte*) + +declare int %fputs_unlocked(sbyte*, sbyte*) + +int %function(int %a.1) { +entry: ; No predecessors! + %a.0 = alloca int ; <int*> [#uses=2] + %result = alloca int ; <int*> [#uses=2] + store int %a.1, int* %a.0 + %tmp.0 = load int* %a.0 ; <int> [#uses=1] + %tmp.1 = load int* %silly ; <int> [#uses=1] + %tmp.2 = add int %tmp.0, %tmp.1 ; <int> [#uses=1] + store int %tmp.2, int* %result + br label %return + +return: ; preds = %entry + %tmp.3 = load int* %result ; <int> [#uses=1] + ret int %tmp.3 +} diff --git a/llvm/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll b/llvm/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll new file mode 100644 index 00000000000..52b778c10d0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-08-12-AllocaNonNull.ll @@ -0,0 +1,22 @@ +; This testcase can be simplified by "realizing" that alloca can never return +; null. +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -simplifycfg | llvm-dis | not grep 'br ' + +implementation ; Functions: + +declare int %bitmap_clear(...) + +int %oof() { +entry: + %live_head = alloca int ; <int*> [#uses=2] + %tmp.1 = setne int* %live_head, null ; <bool> [#uses=1] + br bool %tmp.1, label %then, label %UnifiedExitNode + +then: + %tmp.4 = call int (...)* %bitmap_clear( int* %live_head ) ; <int> [#uses=0] + br label %UnifiedExitNode + +UnifiedExitNode: + ret int 0 +} + diff --git a/llvm/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll b/llvm/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll new file mode 100644 index 00000000000..adb1474a98c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-09-09-VolatileLoadElim.ll @@ -0,0 +1,5 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep load +void %test(int* %P) { + %X = volatile load int* %P ; Dead but not deletable! + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll b/llvm/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll new file mode 100644 index 00000000000..837494f5301 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-10-23-InstcombineNullFail.ll @@ -0,0 +1,13 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep false +; +; This actually looks like a constant propagation bug + +%X = type { [10 x int], float } + +implementation + +bool %test() { + %A = getelementptr %X* null, long 0, uint 0, long 0 + %B = setne int* %A, null + ret bool %B +} diff --git a/llvm/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll b/llvm/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll new file mode 100644 index 00000000000..d23dc32a074 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-10-29-CallSiteResolve.ll @@ -0,0 +1,13 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +declare int* %bar() + +float* %foo() { + %tmp.11 = invoke float* cast (int* ()* %bar to float* ()*)() + to label %invoke_cont except label %X + +invoke_cont: + ret float *%tmp.11 +X: + ret float *null +} diff --git a/llvm/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll b/llvm/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll new file mode 100644 index 00000000000..a2e28d97a11 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-11-03-VarargsCallBug.ll @@ -0,0 +1,13 @@ +; The cast in this testcase is not eliminable on a 32-bit target! +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep inttoptr + +target endian = little +target pointersize = 32 + +declare void %foo(...) + +void %test(long %X) { + %Y = cast long %X to int* + call void (...)* %foo(int* %Y) + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll b/llvm/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll new file mode 100644 index 00000000000..d257286d859 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2003-11-13-ConstExprCastCall.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep call | notcast + +declare void %free(sbyte*) + +void %test(int* %X) { + call int (...)* cast (void (sbyte*)* %free to int (...)*)(int * %X) + ret void +} + diff --git a/llvm/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll b/llvm/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll new file mode 100644 index 00000000000..ff90c32dafa --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-01-13-InstCombineInvokePHI.ll @@ -0,0 +1,24 @@ +; Test for a problem afflicting several C++ programs in the testsuite. The +; instcombine pass is trying to get rid of the cast in the invoke instruction, +; inserting a cast of the return value after the PHI instruction, but which is +; used by the PHI instruction. This is bad: because of the semantics of the +; invoke instruction, we really cannot perform this transformation at all at +; least without splitting the critical edge. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +declare sbyte* %test() + +int %foo() { +entry: + br bool true, label %cont, label %call +call: + %P = invoke int*()* cast (sbyte*()* %test to int*()*)() + to label %cont except label %N +cont: + %P2 = phi int* [%P, %call], [null, %entry] + %V = load int* %P2 + ret int %V +N: + ret int 0 +} diff --git a/llvm/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll b/llvm/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll new file mode 100644 index 00000000000..85095bf0057 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-02-23-ShiftShiftOverflow.ll @@ -0,0 +1,15 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 34 + +int %test(int %X) { + ; Do not fold into shr X, 34, as this uses undefined behavior! + %Y = shr int %X, ubyte 17 + %Z = shr int %Y, ubyte 17 + ret int %Z +} + +int %test2(int %X) { + ; Do not fold into shl X, 34, as this uses undefined behavior! + %Y = shl int %X, ubyte 17 + %Z = shl int %Y, ubyte 17 + ret int %Z +} diff --git a/llvm/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll b/llvm/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll new file mode 100644 index 00000000000..fd7a2e346c9 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-03-13-InstCombineInfLoop.ll @@ -0,0 +1,13 @@ +; This testcase caused the combiner to go into an infinite loop, moving the +; cast back and forth, changing the seteq to operate on int vs uint and back. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +bool %test(uint %A, int %B) { + %C = sub uint 0, %A + %Cc = cast uint %C to int + %D = sub int 0, %B + %E = seteq int %Cc, %D + ret bool %E +} + diff --git a/llvm/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll b/llvm/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll new file mode 100644 index 00000000000..4c6ff1b52bf --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-04-04-InstCombineReplaceAllUsesWith.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +int %test() { + ret int 0 +Loop: + %X = add int %X, 1 + br label %Loop +} diff --git a/llvm/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll b/llvm/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll new file mode 100644 index 00000000000..8e8f019c661 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-05-07-UnsizedCastLoad.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +%Ty = type opaque + +int %test(%Ty *%X) { + %Y = cast %Ty* %X to int* + %Z = load int* %Y + ret int %Z +} diff --git a/llvm/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll b/llvm/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll new file mode 100644 index 00000000000..7994d45c9f4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-07-27-ConstantExprMul.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +%p = weak global int 0 + +int %test(int %x) { + %y = mul int %x, cast (int* %p to int) + ret int %y +} diff --git a/llvm/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx b/llvm/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx new file mode 100644 index 00000000000..98b35fe3cba --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-08-09-RemInfLoop.llx @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine + +; This testcase should not send the instcombiner into an infinite loop! + +int %test(int %X) { + %Y = rem int %X, 0 + ret int %Y +} diff --git a/llvm/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll b/llvm/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll new file mode 100644 index 00000000000..e1144b61b0e --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-08-10-BoolSetCC.ll @@ -0,0 +1,6 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'ret i1 false' +bool %test(bool %V) { + %Y = setlt bool %V, false + ret bool %Y +} + diff --git a/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx b/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx new file mode 100644 index 00000000000..3fcbb88e2de --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine.llx @@ -0,0 +1,20 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -mem2reg | llvm-dis | not grep 'int 1' + +; When propagating the load through the select, make sure that the load is +; inserted where the original load was, not where the select is. Not doing +; so could produce incorrect results! + +implementation + +int %test(bool %C) { + %X = alloca int + %X2 = alloca int + store int 1, int* %X + store int 2, int* %X2 + + %Y = select bool %C, int* %X, int* %X2 + store int 3, int* %X + %Z = load int* %Y + ret int %Z +} + diff --git a/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx b/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx new file mode 100644 index 00000000000..83acd702c66 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-09-20-BadLoadCombine2.llx @@ -0,0 +1,24 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -mem2reg -simplifycfg | llvm-dis | \ +; RUN: grep -v store | not grep 'int 1' + +; Test to make sure that instcombine does not accidentally propagate the load +; into the PHI, which would break the program. + +int %test(bool %C) { +entry: + %X = alloca int + %X2 = alloca int + store int 1, int* %X + store int 2, int* %X2 + br bool %C, label %cond_true.i, label %cond_continue.i + +cond_true.i: + br label %cond_continue.i + +cond_continue.i: + %mem_tmp.i.0 = phi int* [ %X, %cond_true.i ], [ %X2, %entry ] + store int 3, int* %X + %tmp.3 = load int* %mem_tmp.i.0 + ret int %tmp.3 +} + diff --git a/llvm/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx b/llvm/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx new file mode 100644 index 00000000000..bb55b5c67ca --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-09-28-BadShiftAndSetCC.llx @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep -- -65536 + +bool %test(int %tmp.124) { + %tmp.125 = shl int %tmp.124, ubyte 8 + %tmp.126.mask = and int %tmp.125, -16777216 ; <int> [#uses=1] + %tmp.128 = seteq int %tmp.126.mask, 167772160 ; <bool> [#uses=1] + ret bool %tmp.128 +} + diff --git a/llvm/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll b/llvm/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll new file mode 100644 index 00000000000..1a741c996fe --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-11-22-Missed-and-fold.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep and + +sbyte %test21(sbyte %A) { + %C = shr sbyte %A, ubyte 7 ;; sign extend + %D = and sbyte %C, 1 ;; chop off sign + ret sbyte %D +} + diff --git a/llvm/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll b/llvm/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll new file mode 100644 index 00000000000..17958e198a4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-11-27-SetCCForCastLargerAndConstant.ll @@ -0,0 +1,134 @@ +; This test case tests the InstructionCombining optimization that +; reduces things like: +; %Y = cast sbyte %X to uint +; %C = setlt uint %Y, 1024 +; to +; %C = bool true +; It includes test cases for different constant values, signedness of the +; cast operands, and types of setCC operators. In all cases, the cast should +; be eliminated. In many cases the setCC is also eliminated based on the +; constant value and the range of the casted value. +; +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | notcast '.*int' + +implementation ; Functions: + +bool %lt_signed_to_large_unsigned(sbyte %SB) { + %Y = cast sbyte %SB to uint ; <uint> [#uses=1] + %C = setlt uint %Y, 1024 ; <bool> [#uses=1] + ret bool %C +} + +bool %lt_signed_to_large_signed(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setlt int %Y, 1024 + ret bool %C +} + +bool %lt_signed_to_large_negative(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setlt int %Y, -1024 + ret bool %C +} + +bool %lt_signed_to_small_signed(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setlt int %Y, 17 + ret bool %C +} + +bool %lt_signed_to_small_negative(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setlt int %Y, -17 + ret bool %C +} + +bool %lt_unsigned_to_large_unsigned(ubyte %SB) { + %Y = cast ubyte %SB to uint ; <uint> [#uses=1] + %C = setlt uint %Y, 1024 ; <bool> [#uses=1] + ret bool %C +} + +bool %lt_unsigned_to_large_signed(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setlt int %Y, 1024 + ret bool %C +} + +bool %lt_unsigned_to_large_negative(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setlt int %Y, -1024 + ret bool %C +} + +bool %lt_unsigned_to_small_unsigned(ubyte %SB) { + %Y = cast ubyte %SB to uint ; <uint> [#uses=1] + %C = setlt uint %Y, 17 ; <bool> [#uses=1] + ret bool %C +} + +bool %lt_unsigned_to_small_negative(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setlt int %Y, -17 + ret bool %C +} + +bool %gt_signed_to_large_unsigned(sbyte %SB) { + %Y = cast sbyte %SB to uint ; <uint> [#uses=1] + %C = setgt uint %Y, 1024 ; <bool> [#uses=1] + ret bool %C +} + +bool %gt_signed_to_large_signed(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setgt int %Y, 1024 + ret bool %C +} + +bool %gt_signed_to_large_negative(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setgt int %Y, -1024 + ret bool %C +} + +bool %gt_signed_to_small_signed(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setgt int %Y, 17 + ret bool %C +} + +bool %gt_signed_to_small_negative(sbyte %SB) { + %Y = cast sbyte %SB to int + %C = setgt int %Y, -17 + ret bool %C +} + +bool %gt_unsigned_to_large_unsigned(ubyte %SB) { + %Y = cast ubyte %SB to uint ; <uint> [#uses=1] + %C = setgt uint %Y, 1024 ; <bool> [#uses=1] + ret bool %C +} + +bool %gt_unsigned_to_large_signed(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setgt int %Y, 1024 + ret bool %C +} + +bool %gt_unsigned_to_large_negative(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setgt int %Y, -1024 + ret bool %C +} + +bool %gt_unsigned_to_small_unsigned(ubyte %SB) { + %Y = cast ubyte %SB to uint ; <uint> [#uses=1] + %C = setgt uint %Y, 17 ; <bool> [#uses=1] + ret bool %C +} + +bool %gt_unsigned_to_small_negative(ubyte %SB) { + %Y = cast ubyte %SB to int + %C = setgt int %Y, -17 + ret bool %C +} diff --git a/llvm/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll b/llvm/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll new file mode 100644 index 00000000000..6e241f4e782 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-12-08-InstCombineCrash.ll @@ -0,0 +1,14 @@ +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine + + %struct.llvm_java_object_base = type opaque + "java/lang/Object" = type { %struct.llvm_java_object_base } + "java/lang/StringBuffer" = type { "java/lang/Object", int, { "java/lang/Object", uint, [0 x ushort] }*, bool } + +implementation ; Functions: + +void "java/lang/StringBuffer/append(Ljava/lang/String;)Ljava/lang/StringBuffer;"() { +bc0: + %tmp53 = getelementptr "java/lang/StringBuffer"* null, int 0, uint 1 ; <int*> [#uses=1] + store int 0, int* %tmp53 + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll b/llvm/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll new file mode 100644 index 00000000000..fb18ea24c10 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2004-12-08-RemInfiniteLoop.ll @@ -0,0 +1,6 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine + +int %test(int %X) { + %Y = rem int %X, undef + ret int %Y +} diff --git a/llvm/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll b/llvm/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll new file mode 100644 index 00000000000..c203bb1c442 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-03-04-ShiftOverflow.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'ret bool false' +bool %test(ulong %tmp.169) { + %tmp.1710 = shr ulong %tmp.169, ubyte 1 + %tmp.1912 = setgt ulong %tmp.1710, 0 + ret bool %tmp.1912 +} + diff --git a/llvm/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll b/llvm/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll new file mode 100644 index 00000000000..8e523d3faef --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-04-07-UDivSelectCrash.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +uint %test(bool %C, uint %tmp.15) { + %tmp.16 = select bool %C, uint 8, uint 1 + %tmp.18 = div uint %tmp.15, %tmp.16 + ret uint %tmp.18 +} diff --git a/llvm/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll b/llvm/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll new file mode 100644 index 00000000000..fa862fed2a8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-06-15-DivSelectCrash.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +int %_Z13func_31585107li(int %l_39521025, int %l_59244666) { + %shortcirc_val = select bool false, uint 1, uint 0 ; <uint> [#uses=1] + %tmp.8 = div uint 0, %shortcirc_val ; <uint> [#uses=1] + %tmp.9 = seteq uint %tmp.8, 0 ; <bool> [#uses=1] + %retval = select bool %tmp.9, int %l_59244666, int -1621308501 ; <int> [#uses=1] + ret int %retval +} diff --git a/llvm/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll b/llvm/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll new file mode 100644 index 00000000000..deb61246cf3 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-06-15-ShiftSetCCCrash.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +; PR577 + +bool %test() { + %tmp.3 = shl int 0, ubyte 41 ; <int> [#uses=1] + %tmp.4 = setne int %tmp.3, 0 ; <bool> [#uses=1] + ret bool %tmp.4 +} diff --git a/llvm/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll b/llvm/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll new file mode 100644 index 00000000000..ef443012252 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-06-16-RangeCrash.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +; PR585 +bool %test() { + %tmp.26 = div int 0, -2147483648 ; <int> [#uses=1] + %tmp.27 = seteq int %tmp.26, 0 ; <bool> [#uses=1] + ret bool %tmp.27 +} diff --git a/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll b/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll new file mode 100644 index 00000000000..f4d6703873b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-06-16-SetCCOrSetCCMiscompile.ll @@ -0,0 +1,16 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'ret i1 true' +; PR586 + +%g_07918478 = external global uint ; <uint*> [#uses=1] + +implementation ; Functions: + +bool %test() { + %tmp.0 = load uint* %g_07918478 ; <uint> [#uses=2] + %tmp.1 = setne uint %tmp.0, 0 ; <bool> [#uses=1] + %tmp.4 = setlt uint %tmp.0, 4111 ; <bool> [#uses=1] + %bothcond = or bool %tmp.1, %tmp.4 ; <bool> [#uses=1] + ret bool %bothcond +} + diff --git a/llvm/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll b/llvm/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll new file mode 100644 index 00000000000..be9837dc43a --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2005-07-07-DeadPHILoop.ll @@ -0,0 +1,13 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +; This example caused instcombine to spin into an infinite loop. + +void %test(int *%P) { + ret void +Dead: + %X = phi int [%Y, %Dead] + %Y = div int %X, 10 + store int %Y, int* %P + br label %Dead +} + diff --git a/llvm/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll b/llvm/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll new file mode 100644 index 00000000000..e06dca914e0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-02-07-SextZextCrash.ll @@ -0,0 +1,22 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + + %struct.rtx_const = type { uint, { %union.real_extract } } + %struct.rtx_def = type { int, [1 x %union.rtunion_def] } + %union.real_extract = type { double } + %union.rtunion_def = type { uint } + +implementation ; Functions: + +fastcc void %decode_rtx_const(%struct.rtx_def* %x, %struct.rtx_const* %value) { + %tmp.54 = getelementptr %struct.rtx_const* %value, int 0, uint 0 ; <uint*> [#uses=1] + %tmp.56 = getelementptr %struct.rtx_def* %x, int 0, uint 0 ; <int*> [#uses=1] + %tmp.57 = load int* %tmp.56 ; <int> [#uses=1] + %tmp.58 = shl int %tmp.57, ubyte 8 ; <int> [#uses=1] + %tmp.59 = shr int %tmp.58, ubyte 24 ; <int> [#uses=1] + %tmp.60 = cast int %tmp.59 to ushort ; <ushort> [#uses=1] + %tmp.61 = cast ushort %tmp.60 to uint ; <uint> [#uses=1] + %tmp.62 = shl uint %tmp.61, ubyte 16 ; <uint> [#uses=1] + %tmp.65 = or uint 0, %tmp.62 ; <uint> [#uses=1] + store uint %tmp.65, uint* %tmp.54 + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll b/llvm/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll new file mode 100644 index 00000000000..f3457751492 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-02-13-DemandedMiscompile.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep undef + +int %test(sbyte %A) { + %B = cast sbyte %A to int + %C = shr int %B, ubyte 8 + ret int %C +} + diff --git a/llvm/test/Transforms/InstCombine/2006-02-28-Crash.ll b/llvm/test/Transforms/InstCombine/2006-02-28-Crash.ll new file mode 100644 index 00000000000..241c254dc4a --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-02-28-Crash.ll @@ -0,0 +1,6 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +int %test() { + %tmp203 = seteq uint 1, 2 ; <bool> [#uses=1] + %tmp203 = cast bool %tmp203 to int ; <int> [#uses=1] + ret int %tmp203 +} diff --git a/llvm/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll b/llvm/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll new file mode 100644 index 00000000000..314946085f5 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-03-30-ExtractElement.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +float %test(<4 x float> %V) { + %V2 = insertelement <4 x float> %V, float 1.0, uint 3 + %R = extractelement <4 x float> %V2, uint 2 + ret float %R +} diff --git a/llvm/test/Transforms/InstCombine/2006-04-01-InfLoop.ll b/llvm/test/Transforms/InstCombine/2006-04-01-InfLoop.ll new file mode 100644 index 00000000000..260b9b3ff4c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-04-01-InfLoop.ll @@ -0,0 +1,441 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + + %struct.DecRefPicMarking_s = type { int, int, int, int, int, %struct.DecRefPicMarking_s* } + %struct.datapartition = type { %typedef.Bitstream*, %typedef.DecodingEnvironment, int (%struct.syntaxelement*, %struct.img_par*, %struct.inp_par*, %struct.datapartition*)* } + %struct.img_par = type { int, uint, uint, int, int*, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, [16 x [16 x ushort]], [6 x [32 x int]], [16 x [16 x int]], [4 x [12 x [4 x [4 x int]]]], [16 x int], int**, int*, int***, int**, int, int, int, int, %typedef.Slice*, %struct.macroblock*, int, int, int, int, int, int, int**, %struct.DecRefPicMarking_s*, int, int, int, int, int, int, int, uint, int, int, int, uint, uint, uint, uint, int, [3 x int], int, uint, int, uint, int, int, int, uint, uint, int, int, int, int, uint, uint, int***, int***, int****, int, int, uint, int, int, int, int, uint, uint, uint, uint, uint, uint, uint, int, int, int, int, int, int, int, int, int, int, int, uint, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, %struct.timeb, %struct.timeb, int, int, int, int, int, uint, int, int } + %struct.inp_par = type { [100 x sbyte], [100 x sbyte], [100 x sbyte], int, int, int, int, int, int, int } + %struct.macroblock = type { int, int, int, %struct.macroblock*, %struct.macroblock*, int, [2 x [4 x [4 x [2 x int]]]], int, long, long, int, int, [4 x int], [4 x int], int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int } + %struct.pix_pos = type { int, int, int, int, int, int } + %struct.storable_picture = type { uint, int, int, int, int, [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], [50 x [6 x [33 x long]]], uint, int, int, int, int, int, int, int, short, int, int, int, int, int, int, int, uint, uint, ushort**, ushort***, ubyte*, short**, sbyte***, long***, long***, short****, ubyte**, ubyte**, %struct.storable_picture*, %struct.storable_picture*, %struct.storable_picture*, int, int, int, int, int, int, int, int, int, int, int, int, int, [2 x int], int, %struct.DecRefPicMarking_s*, int } + %struct.syntaxelement = type { int, int, int, int, int, uint, int, int, void (int, int, int*, int*)*, void (%struct.syntaxelement*, %struct.inp_par*, %struct.img_par*, %typedef.DecodingEnvironment*)* } + %struct.timeb = type { int, ushort, short, short } + %typedef.BiContextType = type { ushort, ubyte } + %typedef.Bitstream = type { int, int, int, int, ubyte*, int } + %typedef.DecodingEnvironment = type { uint, uint, uint, uint, int, ubyte*, int* } + %typedef.MotionInfoContexts = type { [4 x [11 x %typedef.BiContextType]], [2 x [9 x %typedef.BiContextType]], [2 x [10 x %typedef.BiContextType]], [2 x [6 x %typedef.BiContextType]], [4 x %typedef.BiContextType], [4 x %typedef.BiContextType], [3 x %typedef.BiContextType] } + %typedef.Slice = type { int, int, int, int, uint, int, int, int, int, %struct.datapartition*, %typedef.MotionInfoContexts*, %typedef.TextureInfoContexts*, int, int*, int*, int*, int, int*, int*, int*, int (%struct.img_par*, %struct.inp_par*)*, int, int, int, int } + %typedef.TextureInfoContexts = type { [2 x %typedef.BiContextType], [4 x %typedef.BiContextType], [3 x [4 x %typedef.BiContextType]], [10 x [4 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [5 x %typedef.BiContextType]], [10 x [5 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]], [10 x [15 x %typedef.BiContextType]] } +%dec_picture = external global %struct.storable_picture* ; <%struct.storable_picture**> [#uses=1] +%last_dquant = external global int ; <int*> [#uses=1] + +implementation ; Functions: + +void %readCBP_CABAC(%struct.syntaxelement* %se, %struct.inp_par* %inp, %struct.img_par* %img.1, %typedef.DecodingEnvironment* %dep_dp) { +entry: + %block_a = alloca %struct.pix_pos ; <%struct.pix_pos*> [#uses=5] + %tmp.1 = getelementptr %struct.img_par* %img.1, int 0, uint 37 ; <%typedef.Slice**> [#uses=1] + %tmp.2 = load %typedef.Slice** %tmp.1 ; <%typedef.Slice*> [#uses=1] + %tmp.3 = getelementptr %typedef.Slice* %tmp.2, int 0, uint 11 ; <%typedef.TextureInfoContexts**> [#uses=1] + %tmp.4 = load %typedef.TextureInfoContexts** %tmp.3 ; <%typedef.TextureInfoContexts*> [#uses=3] + %tmp.6 = getelementptr %struct.img_par* %img.1, int 0, uint 38 ; <%struct.macroblock**> [#uses=1] + %tmp.7 = load %struct.macroblock** %tmp.6 ; <%struct.macroblock*> [#uses=1] + %tmp.9 = getelementptr %struct.img_par* %img.1, int 0, uint 1 ; <uint*> [#uses=1] + %tmp.10 = load uint* %tmp.9 ; <uint> [#uses=1] + %tmp.11 = cast uint %tmp.10 to int ; <int> [#uses=1] + %tmp.12 = getelementptr %struct.macroblock* %tmp.7, int %tmp.11 ; <%struct.macroblock*> [#uses=18] + br label %loopentry.0 + +loopentry.0: ; preds = %loopexit.1, %entry + %mask.1 = phi int [ undef, %entry ], [ %mask.0, %loopexit.1 ] ; <int> [#uses=1] + %cbp_bit.1 = phi int [ undef, %entry ], [ %cbp_bit.0, %loopexit.1 ] ; <int> [#uses=1] + %cbp.2 = phi int [ 0, %entry ], [ %cbp.1, %loopexit.1 ] ; <int> [#uses=5] + %curr_cbp_ctx.1 = phi int [ undef, %entry ], [ %curr_cbp_ctx.0, %loopexit.1 ] ; <int> [#uses=1] + %b.2 = phi int [ undef, %entry ], [ %b.1, %loopexit.1 ] ; <int> [#uses=1] + %a.2 = phi int [ undef, %entry ], [ %a.1, %loopexit.1 ] ; <int> [#uses=1] + %mb_y.0 = phi int [ 0, %entry ], [ %tmp.152, %loopexit.1 ] ; <int> [#uses=7] + %mb_x.0 = phi int [ undef, %entry ], [ %mb_x.1, %loopexit.1 ] ; <int> [#uses=0] + %tmp.14 = setle int %mb_y.0, 3 ; <bool> [#uses=2] + %tmp.15 = cast bool %tmp.14 to int ; <int> [#uses=0] + br bool %tmp.14, label %no_exit.0, label %loopexit.0 + +no_exit.0: ; preds = %loopentry.0 + br label %loopentry.1 + +loopentry.1: ; preds = %endif.7, %no_exit.0 + %mask.0 = phi int [ %mask.1, %no_exit.0 ], [ %tmp.131, %endif.7 ] ; <int> [#uses=1] + %cbp_bit.0 = phi int [ %cbp_bit.1, %no_exit.0 ], [ %tmp.142, %endif.7 ] ; <int> [#uses=1] + %cbp.1 = phi int [ %cbp.2, %no_exit.0 ], [ %cbp.0, %endif.7 ] ; <int> [#uses=5] + %curr_cbp_ctx.0 = phi int [ %curr_cbp_ctx.1, %no_exit.0 ], [ %tmp.125, %endif.7 ] ; <int> [#uses=1] + %b.1 = phi int [ %b.2, %no_exit.0 ], [ %b.0, %endif.7 ] ; <int> [#uses=1] + %a.1 = phi int [ %a.2, %no_exit.0 ], [ %a.0, %endif.7 ] ; <int> [#uses=1] + %mb_x.1 = phi int [ 0, %no_exit.0 ], [ %tmp.150, %endif.7 ] ; <int> [#uses=9] + %tmp.17 = setle int %mb_x.1, 3 ; <bool> [#uses=2] + %tmp.18 = cast bool %tmp.17 to int ; <int> [#uses=0] + br bool %tmp.17, label %no_exit.1, label %loopexit.1 + +no_exit.1: ; preds = %loopentry.1 + %tmp.20 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 12 ; <[4 x int]*> [#uses=1] + %tmp.22 = div int %mb_x.1, 2 ; <int> [#uses=1] + %tmp.24 = add int %tmp.22, %mb_y.0 ; <int> [#uses=1] + %tmp.25 = getelementptr [4 x int]* %tmp.20, int 0, int %tmp.24 ; <int*> [#uses=1] + %tmp.26 = load int* %tmp.25 ; <int> [#uses=1] + %tmp.27 = seteq int %tmp.26, 11 ; <bool> [#uses=2] + %tmp.28 = cast bool %tmp.27 to int ; <int> [#uses=0] + br bool %tmp.27, label %then.0, label %else.0 + +then.0: ; preds = %no_exit.1 + br label %endif.0 + +else.0: ; preds = %no_exit.1 + br label %endif.0 + +endif.0: ; preds = %else.0, %then.0 + %tmp.30 = seteq int %mb_y.0, 0 ; <bool> [#uses=2] + %tmp.31 = cast bool %tmp.30 to int ; <int> [#uses=0] + br bool %tmp.30, label %then.1, label %else.1 + +then.1: ; preds = %endif.0 + %tmp.33 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.34 = load %struct.macroblock** %tmp.33 ; <%struct.macroblock*> [#uses=1] + %tmp.35 = cast %struct.macroblock* %tmp.34 to sbyte* ; <sbyte*> [#uses=1] + %tmp.36 = seteq sbyte* %tmp.35, null ; <bool> [#uses=2] + %tmp.37 = cast bool %tmp.36 to int ; <int> [#uses=0] + br bool %tmp.36, label %then.2, label %else.2 + +then.2: ; preds = %then.1 + br label %endif.1 + +else.2: ; preds = %then.1 + %tmp.39 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.40 = load %struct.macroblock** %tmp.39 ; <%struct.macroblock*> [#uses=1] + %tmp.41 = getelementptr %struct.macroblock* %tmp.40, int 0, uint 5 ; <int*> [#uses=1] + %tmp.42 = load int* %tmp.41 ; <int> [#uses=1] + %tmp.43 = seteq int %tmp.42, 14 ; <bool> [#uses=2] + %tmp.44 = cast bool %tmp.43 to int ; <int> [#uses=0] + br bool %tmp.43, label %then.3, label %else.3 + +then.3: ; preds = %else.2 + br label %endif.1 + +else.3: ; preds = %else.2 + %tmp.46 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.47 = load %struct.macroblock** %tmp.46 ; <%struct.macroblock*> [#uses=1] + %tmp.48 = getelementptr %struct.macroblock* %tmp.47, int 0, uint 7 ; <int*> [#uses=1] + %tmp.49 = load int* %tmp.48 ; <int> [#uses=1] + %tmp.51 = div int %mb_x.1, 2 ; <int> [#uses=1] + %tmp.52 = add int %tmp.51, 2 ; <int> [#uses=1] + %tmp.53 = cast int %tmp.52 to ubyte ; <ubyte> [#uses=1] + %tmp.54 = shr int %tmp.49, ubyte %tmp.53 ; <int> [#uses=1] + %tmp.55 = cast int %tmp.54 to uint ; <uint> [#uses=1] + %tmp.57 = xor uint %tmp.55, 1 ; <uint> [#uses=1] + %tmp.58 = cast uint %tmp.57 to int ; <int> [#uses=1] + %tmp.59 = and int %tmp.58, 1 ; <int> [#uses=1] + br label %endif.1 + +else.1: ; preds = %endif.0 + %tmp.62 = div int %mb_x.1, 2 ; <int> [#uses=1] + %tmp.63 = cast int %tmp.62 to ubyte ; <ubyte> [#uses=1] + %tmp.64 = shr int %cbp.1, ubyte %tmp.63 ; <int> [#uses=1] + %tmp.65 = cast int %tmp.64 to uint ; <uint> [#uses=1] + %tmp.67 = xor uint %tmp.65, 1 ; <uint> [#uses=1] + %tmp.68 = cast uint %tmp.67 to int ; <int> [#uses=1] + %tmp.69 = and int %tmp.68, 1 ; <int> [#uses=1] + br label %endif.1 + +endif.1: ; preds = %else.1, %else.3, %then.3, %then.2 + %b.0 = phi int [ 0, %then.2 ], [ 0, %then.3 ], [ %tmp.59, %else.3 ], [ %tmp.69, %else.1 ] ; <int> [#uses=2] + %tmp.71 = seteq int %mb_x.1, 0 ; <bool> [#uses=2] + %tmp.72 = cast bool %tmp.71 to int ; <int> [#uses=0] + br bool %tmp.71, label %then.4, label %else.4 + +then.4: ; preds = %endif.1 + %tmp.74 = getelementptr %struct.img_par* %img.1, int 0, uint 1 ; <uint*> [#uses=1] + %tmp.75 = load uint* %tmp.74 ; <uint> [#uses=1] + %tmp.76 = cast uint %tmp.75 to int ; <int> [#uses=1] + call void %getLuma4x4Neighbour( int %tmp.76, int %mb_x.1, int %mb_y.0, int -1, int 0, %struct.pix_pos* %block_a ) + %tmp.79 = getelementptr %struct.pix_pos* %block_a, int 0, uint 0 ; <int*> [#uses=1] + %tmp.80 = load int* %tmp.79 ; <int> [#uses=1] + %tmp.81 = setne int %tmp.80, 0 ; <bool> [#uses=2] + %tmp.82 = cast bool %tmp.81 to int ; <int> [#uses=0] + br bool %tmp.81, label %then.5, label %else.5 + +then.5: ; preds = %then.4 + %tmp.84 = getelementptr %struct.img_par* %img.1, int 0, uint 38 ; <%struct.macroblock**> [#uses=1] + %tmp.85 = load %struct.macroblock** %tmp.84 ; <%struct.macroblock*> [#uses=1] + %tmp.86 = getelementptr %struct.pix_pos* %block_a, int 0, uint 1 ; <int*> [#uses=1] + %tmp.87 = load int* %tmp.86 ; <int> [#uses=1] + %tmp.88 = getelementptr %struct.macroblock* %tmp.85, int %tmp.87 ; <%struct.macroblock*> [#uses=1] + %tmp.89 = getelementptr %struct.macroblock* %tmp.88, int 0, uint 5 ; <int*> [#uses=1] + %tmp.90 = load int* %tmp.89 ; <int> [#uses=1] + %tmp.91 = seteq int %tmp.90, 14 ; <bool> [#uses=2] + %tmp.92 = cast bool %tmp.91 to int ; <int> [#uses=0] + br bool %tmp.91, label %then.6, label %else.6 + +then.6: ; preds = %then.5 + br label %endif.4 + +else.6: ; preds = %then.5 + %tmp.94 = getelementptr %struct.img_par* %img.1, int 0, uint 38 ; <%struct.macroblock**> [#uses=1] + %tmp.95 = load %struct.macroblock** %tmp.94 ; <%struct.macroblock*> [#uses=1] + %tmp.96 = getelementptr %struct.pix_pos* %block_a, int 0, uint 1 ; <int*> [#uses=1] + %tmp.97 = load int* %tmp.96 ; <int> [#uses=1] + %tmp.98 = getelementptr %struct.macroblock* %tmp.95, int %tmp.97 ; <%struct.macroblock*> [#uses=1] + %tmp.99 = getelementptr %struct.macroblock* %tmp.98, int 0, uint 7 ; <int*> [#uses=1] + %tmp.100 = load int* %tmp.99 ; <int> [#uses=1] + %tmp.101 = getelementptr %struct.pix_pos* %block_a, int 0, uint 3 ; <int*> [#uses=1] + %tmp.102 = load int* %tmp.101 ; <int> [#uses=1] + %tmp.103 = div int %tmp.102, 2 ; <int> [#uses=1] + %tmp.104 = mul int %tmp.103, 2 ; <int> [#uses=1] + %tmp.105 = add int %tmp.104, 1 ; <int> [#uses=1] + %tmp.106 = cast int %tmp.105 to ubyte ; <ubyte> [#uses=1] + %tmp.107 = shr int %tmp.100, ubyte %tmp.106 ; <int> [#uses=1] + %tmp.108 = cast int %tmp.107 to uint ; <uint> [#uses=1] + %tmp.110 = xor uint %tmp.108, 1 ; <uint> [#uses=1] + %tmp.111 = cast uint %tmp.110 to int ; <int> [#uses=1] + %tmp.112 = and int %tmp.111, 1 ; <int> [#uses=1] + br label %endif.4 + +else.5: ; preds = %then.4 + br label %endif.4 + +else.4: ; preds = %endif.1 + %tmp.115 = cast int %mb_y.0 to ubyte ; <ubyte> [#uses=1] + %tmp.116 = shr int %cbp.1, ubyte %tmp.115 ; <int> [#uses=1] + %tmp.117 = cast int %tmp.116 to uint ; <uint> [#uses=1] + %tmp.119 = xor uint %tmp.117, 1 ; <uint> [#uses=1] + %tmp.120 = cast uint %tmp.119 to int ; <int> [#uses=1] + %tmp.121 = and int %tmp.120, 1 ; <int> [#uses=1] + br label %endif.4 + +endif.4: ; preds = %else.4, %else.5, %else.6, %then.6 + %a.0 = phi int [ 0, %then.6 ], [ %tmp.112, %else.6 ], [ 0, %else.5 ], [ %tmp.121, %else.4 ] ; <int> [#uses=2] + %tmp.123 = mul int %b.0, 2 ; <int> [#uses=1] + %tmp.125 = add int %tmp.123, %a.0 ; <int> [#uses=2] + %tmp.127 = div int %mb_x.1, 2 ; <int> [#uses=1] + %tmp.129 = add int %tmp.127, %mb_y.0 ; <int> [#uses=1] + %tmp.130 = cast int %tmp.129 to ubyte ; <ubyte> [#uses=1] + %tmp.131 = shl int 1, ubyte %tmp.130 ; <int> [#uses=2] + %tmp.135 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2 ; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1] + %tmp.136 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.135, int 0, int 0 ; <[4 x %typedef.BiContextType]*> [#uses=1] + %tmp.137 = getelementptr [4 x %typedef.BiContextType]* %tmp.136, int 0, int 0 ; <%typedef.BiContextType*> [#uses=1] + %tmp.139 = cast int %tmp.125 to uint ; <uint> [#uses=1] + %tmp.140 = cast uint %tmp.139 to int ; <int> [#uses=1] + %tmp.141 = getelementptr %typedef.BiContextType* %tmp.137, int %tmp.140 ; <%typedef.BiContextType*> [#uses=1] + %tmp.132 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.141 ) ; <uint> [#uses=1] + %tmp.142 = cast uint %tmp.132 to int ; <int> [#uses=2] + %tmp.144 = setne int %tmp.142, 0 ; <bool> [#uses=2] + %tmp.145 = cast bool %tmp.144 to int ; <int> [#uses=0] + br bool %tmp.144, label %then.7, label %endif.7 + +then.7: ; preds = %endif.4 + %tmp.148 = add int %cbp.1, %tmp.131 ; <int> [#uses=1] + br label %endif.7 + +endif.7: ; preds = %then.7, %endif.4 + %cbp.0 = phi int [ %tmp.148, %then.7 ], [ %cbp.1, %endif.4 ] ; <int> [#uses=1] + %tmp.150 = add int %mb_x.1, 2 ; <int> [#uses=1] + br label %loopentry.1 + +loopexit.1: ; preds = %loopentry.1 + %tmp.152 = add int %mb_y.0, 2 ; <int> [#uses=1] + br label %loopentry.0 + +loopexit.0: ; preds = %loopentry.0 + %tmp.153 = load %struct.storable_picture** %dec_picture ; <%struct.storable_picture*> [#uses=1] + %tmp.154 = getelementptr %struct.storable_picture* %tmp.153, int 0, uint 45 ; <int*> [#uses=1] + %tmp.155 = load int* %tmp.154 ; <int> [#uses=1] + %tmp.156 = setne int %tmp.155, 0 ; <bool> [#uses=2] + %tmp.157 = cast bool %tmp.156 to int ; <int> [#uses=0] + br bool %tmp.156, label %then.8, label %endif.8 + +then.8: ; preds = %loopexit.0 + %tmp.159 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.160 = load %struct.macroblock** %tmp.159 ; <%struct.macroblock*> [#uses=1] + %tmp.161 = cast %struct.macroblock* %tmp.160 to sbyte* ; <sbyte*> [#uses=1] + %tmp.162 = setne sbyte* %tmp.161, null ; <bool> [#uses=2] + %tmp.163 = cast bool %tmp.162 to int ; <int> [#uses=0] + br bool %tmp.162, label %then.9, label %endif.9 + +then.9: ; preds = %then.8 + %tmp.165 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.166 = load %struct.macroblock** %tmp.165 ; <%struct.macroblock*> [#uses=1] + %tmp.167 = getelementptr %struct.macroblock* %tmp.166, int 0, uint 5 ; <int*> [#uses=1] + %tmp.168 = load int* %tmp.167 ; <int> [#uses=1] + %tmp.169 = seteq int %tmp.168, 14 ; <bool> [#uses=2] + %tmp.170 = cast bool %tmp.169 to int ; <int> [#uses=0] + br bool %tmp.169, label %then.10, label %else.7 + +then.10: ; preds = %then.9 + br label %endif.9 + +else.7: ; preds = %then.9 + %tmp.172 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.173 = load %struct.macroblock** %tmp.172 ; <%struct.macroblock*> [#uses=1] + %tmp.174 = getelementptr %struct.macroblock* %tmp.173, int 0, uint 7 ; <int*> [#uses=1] + %tmp.175 = load int* %tmp.174 ; <int> [#uses=1] + %tmp.176 = setgt int %tmp.175, 15 ; <bool> [#uses=1] + %tmp.177 = cast bool %tmp.176 to int ; <int> [#uses=1] + br label %endif.9 + +endif.9: ; preds = %else.7, %then.10, %then.8 + %b.4 = phi int [ 1, %then.10 ], [ %tmp.177, %else.7 ], [ 0, %then.8 ] ; <int> [#uses=1] + %tmp.179 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.180 = load %struct.macroblock** %tmp.179 ; <%struct.macroblock*> [#uses=1] + %tmp.181 = cast %struct.macroblock* %tmp.180 to sbyte* ; <sbyte*> [#uses=1] + %tmp.182 = setne sbyte* %tmp.181, null ; <bool> [#uses=2] + %tmp.183 = cast bool %tmp.182 to int ; <int> [#uses=0] + br bool %tmp.182, label %then.11, label %endif.11 + +then.11: ; preds = %endif.9 + %tmp.185 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.186 = load %struct.macroblock** %tmp.185 ; <%struct.macroblock*> [#uses=1] + %tmp.187 = getelementptr %struct.macroblock* %tmp.186, int 0, uint 5 ; <int*> [#uses=1] + %tmp.188 = load int* %tmp.187 ; <int> [#uses=1] + %tmp.189 = seteq int %tmp.188, 14 ; <bool> [#uses=2] + %tmp.190 = cast bool %tmp.189 to int ; <int> [#uses=0] + br bool %tmp.189, label %then.12, label %else.8 + +then.12: ; preds = %then.11 + br label %endif.11 + +else.8: ; preds = %then.11 + %tmp.192 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.193 = load %struct.macroblock** %tmp.192 ; <%struct.macroblock*> [#uses=1] + %tmp.194 = getelementptr %struct.macroblock* %tmp.193, int 0, uint 7 ; <int*> [#uses=1] + %tmp.195 = load int* %tmp.194 ; <int> [#uses=1] + %tmp.196 = setgt int %tmp.195, 15 ; <bool> [#uses=1] + %tmp.197 = cast bool %tmp.196 to int ; <int> [#uses=1] + br label %endif.11 + +endif.11: ; preds = %else.8, %then.12, %endif.9 + %a.4 = phi int [ 1, %then.12 ], [ %tmp.197, %else.8 ], [ 0, %endif.9 ] ; <int> [#uses=1] + %tmp.199 = mul int %b.4, 2 ; <int> [#uses=1] + %tmp.201 = add int %tmp.199, %a.4 ; <int> [#uses=1] + %tmp.205 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2 ; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1] + %tmp.206 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.205, int 0, int 1 ; <[4 x %typedef.BiContextType]*> [#uses=1] + %tmp.207 = getelementptr [4 x %typedef.BiContextType]* %tmp.206, int 0, int 0 ; <%typedef.BiContextType*> [#uses=1] + %tmp.209 = cast int %tmp.201 to uint ; <uint> [#uses=1] + %tmp.210 = cast uint %tmp.209 to int ; <int> [#uses=1] + %tmp.211 = getelementptr %typedef.BiContextType* %tmp.207, int %tmp.210 ; <%typedef.BiContextType*> [#uses=1] + %tmp.202 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.211 ) ; <uint> [#uses=1] + %tmp.212 = cast uint %tmp.202 to int ; <int> [#uses=1] + %tmp.214 = setne int %tmp.212, 0 ; <bool> [#uses=2] + %tmp.215 = cast bool %tmp.214 to int ; <int> [#uses=0] + br bool %tmp.214, label %then.13, label %endif.8 + +then.13: ; preds = %endif.11 + %tmp.217 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.218 = load %struct.macroblock** %tmp.217 ; <%struct.macroblock*> [#uses=1] + %tmp.219 = cast %struct.macroblock* %tmp.218 to sbyte* ; <sbyte*> [#uses=1] + %tmp.220 = setne sbyte* %tmp.219, null ; <bool> [#uses=2] + %tmp.221 = cast bool %tmp.220 to int ; <int> [#uses=0] + br bool %tmp.220, label %then.14, label %endif.14 + +then.14: ; preds = %then.13 + %tmp.223 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.224 = load %struct.macroblock** %tmp.223 ; <%struct.macroblock*> [#uses=1] + %tmp.225 = getelementptr %struct.macroblock* %tmp.224, int 0, uint 5 ; <int*> [#uses=1] + %tmp.226 = load int* %tmp.225 ; <int> [#uses=1] + %tmp.227 = seteq int %tmp.226, 14 ; <bool> [#uses=2] + %tmp.228 = cast bool %tmp.227 to int ; <int> [#uses=0] + br bool %tmp.227, label %then.15, label %else.9 + +then.15: ; preds = %then.14 + br label %endif.14 + +else.9: ; preds = %then.14 + %tmp.230 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.231 = load %struct.macroblock** %tmp.230 ; <%struct.macroblock*> [#uses=1] + %tmp.232 = getelementptr %struct.macroblock* %tmp.231, int 0, uint 7 ; <int*> [#uses=1] + %tmp.233 = load int* %tmp.232 ; <int> [#uses=1] + %tmp.234 = setgt int %tmp.233, 15 ; <bool> [#uses=2] + %tmp.235 = cast bool %tmp.234 to int ; <int> [#uses=0] + br bool %tmp.234, label %then.16, label %endif.14 + +then.16: ; preds = %else.9 + %tmp.237 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 3 ; <%struct.macroblock**> [#uses=1] + %tmp.238 = load %struct.macroblock** %tmp.237 ; <%struct.macroblock*> [#uses=1] + %tmp.239 = getelementptr %struct.macroblock* %tmp.238, int 0, uint 7 ; <int*> [#uses=1] + %tmp.240 = load int* %tmp.239 ; <int> [#uses=1] + %tmp.242 = shr int %tmp.240, ubyte 4 ; <int> [#uses=1] + %tmp.243 = seteq int %tmp.242, 2 ; <bool> [#uses=1] + %tmp.244 = cast bool %tmp.243 to int ; <int> [#uses=1] + br label %endif.14 + +endif.14: ; preds = %then.16, %else.9, %then.15, %then.13 + %b.5 = phi int [ 1, %then.15 ], [ %tmp.244, %then.16 ], [ 0, %else.9 ], [ 0, %then.13 ] ; <int> [#uses=1] + %tmp.246 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.247 = load %struct.macroblock** %tmp.246 ; <%struct.macroblock*> [#uses=1] + %tmp.248 = cast %struct.macroblock* %tmp.247 to sbyte* ; <sbyte*> [#uses=1] + %tmp.249 = setne sbyte* %tmp.248, null ; <bool> [#uses=2] + %tmp.250 = cast bool %tmp.249 to int ; <int> [#uses=0] + br bool %tmp.249, label %then.17, label %endif.17 + +then.17: ; preds = %endif.14 + %tmp.252 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.253 = load %struct.macroblock** %tmp.252 ; <%struct.macroblock*> [#uses=1] + %tmp.254 = getelementptr %struct.macroblock* %tmp.253, int 0, uint 5 ; <int*> [#uses=1] + %tmp.255 = load int* %tmp.254 ; <int> [#uses=1] + %tmp.256 = seteq int %tmp.255, 14 ; <bool> [#uses=2] + %tmp.257 = cast bool %tmp.256 to int ; <int> [#uses=0] + br bool %tmp.256, label %then.18, label %else.10 + +then.18: ; preds = %then.17 + br label %endif.17 + +else.10: ; preds = %then.17 + %tmp.259 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.260 = load %struct.macroblock** %tmp.259 ; <%struct.macroblock*> [#uses=1] + %tmp.261 = getelementptr %struct.macroblock* %tmp.260, int 0, uint 7 ; <int*> [#uses=1] + %tmp.262 = load int* %tmp.261 ; <int> [#uses=1] + %tmp.263 = setgt int %tmp.262, 15 ; <bool> [#uses=2] + %tmp.264 = cast bool %tmp.263 to int ; <int> [#uses=0] + br bool %tmp.263, label %then.19, label %endif.17 + +then.19: ; preds = %else.10 + %tmp.266 = getelementptr %struct.macroblock* %tmp.12, int 0, uint 4 ; <%struct.macroblock**> [#uses=1] + %tmp.267 = load %struct.macroblock** %tmp.266 ; <%struct.macroblock*> [#uses=1] + %tmp.268 = getelementptr %struct.macroblock* %tmp.267, int 0, uint 7 ; <int*> [#uses=1] + %tmp.269 = load int* %tmp.268 ; <int> [#uses=1] + %tmp.271 = shr int %tmp.269, ubyte 4 ; <int> [#uses=1] + %tmp.272 = seteq int %tmp.271, 2 ; <bool> [#uses=1] + %tmp.273 = cast bool %tmp.272 to int ; <int> [#uses=1] + br label %endif.17 + +endif.17: ; preds = %then.19, %else.10, %then.18, %endif.14 + %a.5 = phi int [ 1, %then.18 ], [ %tmp.273, %then.19 ], [ 0, %else.10 ], [ 0, %endif.14 ] ; <int> [#uses=1] + %tmp.275 = mul int %b.5, 2 ; <int> [#uses=1] + %tmp.277 = add int %tmp.275, %a.5 ; <int> [#uses=1] + %tmp.281 = getelementptr %typedef.TextureInfoContexts* %tmp.4, int 0, uint 2 ; <[3 x [4 x %typedef.BiContextType]]*> [#uses=1] + %tmp.282 = getelementptr [3 x [4 x %typedef.BiContextType]]* %tmp.281, int 0, int 2 ; <[4 x %typedef.BiContextType]*> [#uses=1] + %tmp.283 = getelementptr [4 x %typedef.BiContextType]* %tmp.282, int 0, int 0 ; <%typedef.BiContextType*> [#uses=1] + %tmp.285 = cast int %tmp.277 to uint ; <uint> [#uses=1] + %tmp.286 = cast uint %tmp.285 to int ; <int> [#uses=1] + %tmp.287 = getelementptr %typedef.BiContextType* %tmp.283, int %tmp.286 ; <%typedef.BiContextType*> [#uses=1] + %tmp.278 = call uint %biari_decode_symbol( %typedef.DecodingEnvironment* %dep_dp, %typedef.BiContextType* %tmp.287 ) ; <uint> [#uses=1] + %tmp.288 = cast uint %tmp.278 to int ; <int> [#uses=1] + %tmp.290 = seteq int %tmp.288, 1 ; <bool> [#uses=2] + %tmp.291 = cast bool %tmp.290 to int ; <int> [#uses=0] + br bool %tmp.290, label %cond_true, label %cond_false + +cond_true: ; preds = %endif.17 + %tmp.293 = add int %cbp.2, 32 ; <int> [#uses=1] + br label %cond_continue + +cond_false: ; preds = %endif.17 + %tmp.295 = add int %cbp.2, 16 ; <int> [#uses=1] + br label %cond_continue + +cond_continue: ; preds = %cond_false, %cond_true + %mem_tmp.0 = phi int [ %tmp.293, %cond_true ], [ %tmp.295, %cond_false ] ; <int> [#uses=1] + br label %endif.8 + +endif.8: ; preds = %cond_continue, %endif.11, %loopexit.0 + %cbp.3 = phi int [ %mem_tmp.0, %cond_continue ], [ %cbp.2, %endif.11 ], [ %cbp.2, %loopexit.0 ] ; <int> [#uses=2] + %tmp.298 = getelementptr %struct.syntaxelement* %se, int 0, uint 1 ; <int*> [#uses=1] + store int %cbp.3, int* %tmp.298 + %tmp.301 = seteq int %cbp.3, 0 ; <bool> [#uses=2] + %tmp.302 = cast bool %tmp.301 to int ; <int> [#uses=0] + br bool %tmp.301, label %then.20, label %return + +then.20: ; preds = %endif.8 + store int 0, int* %last_dquant + ret void + +return: ; preds = %endif.8 + ret void +} + +declare uint %biari_decode_symbol(%typedef.DecodingEnvironment*, %typedef.BiContextType*) + +declare void %getLuma4x4Neighbour(int, int, int, int, int, %struct.pix_pos*) diff --git a/llvm/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll b/llvm/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll new file mode 100644 index 00000000000..12fc742a5fe --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-04-28-ShiftShiftLongLong.ll @@ -0,0 +1,10 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep shl && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast + +; This cannot be turned into a sign extending cast! + +long %test(long %X) { + %Y = shl long %X, ubyte 16 + %Z = shr long %Y, ubyte 16 + ret long %Z +} diff --git a/llvm/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll b/llvm/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll new file mode 100644 index 00000000000..6f95e925c70 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-05-04-DemandedBitCrash.ll @@ -0,0 +1,50 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +void %test() { +bb38.i: + %varspec.0.i1014 = cast long 123814269237067777 to ulong ; <ulong> [#uses=1] + %locspec.0.i1015 = cast int 1 to uint ; <uint> [#uses=2] + %tmp51391.i1018 = shr ulong %varspec.0.i1014, ubyte 16 ; <ulong> [#uses=1] + %tmp51392.i1019 = cast ulong %tmp51391.i1018 to uint ; <uint> [#uses=2] + %tmp51392.mask.i1020 = shr uint %tmp51392.i1019, ubyte 29 ; <uint> [#uses=1] + %tmp7.i1021 = and uint %tmp51392.mask.i1020, 1 ; <uint> [#uses=2] + %tmp18.i1026 = shr uint %tmp51392.i1019, ubyte 31 ; <uint> [#uses=2] + %tmp18.i1027 = cast uint %tmp18.i1026 to ubyte ; <ubyte> [#uses=1] + br bool false, label %cond_false1148.i1653, label %bb377.i1259 + +bb377.i1259: ; preds = %bb38.i + br bool false, label %cond_true541.i1317, label %cond_false1148.i1653 + +cond_true541.i1317: ; preds = %bb377.i1259 + %tmp545.i1318 = shr uint %locspec.0.i1015, ubyte 10 ; <uint> [#uses=1] + %tmp550.i1319 = shr uint %locspec.0.i1015, ubyte 4 ; <uint> [#uses=1] + %tmp550551.i1320 = and uint %tmp550.i1319, 63 ; <uint> [#uses=1] + %tmp553.i1321 = setlt uint %tmp550551.i1320, 4 ; <bool> [#uses=1] + %tmp558.i1322 = seteq uint %tmp7.i1021, 0 ; <bool> [#uses=1] + %bothcond.i1326 = or bool %tmp553.i1321, false ; <bool> [#uses=1] + %bothcond1.i1327 = or bool %bothcond.i1326, false ; <bool> [#uses=1] + %bothcond2.not.i1328 = or bool %bothcond1.i1327, false ; <bool> [#uses=1] + %bothcond3.i1329 = or bool %bothcond2.not.i1328, %tmp558.i1322 ; <bool> [#uses=0] + br bool false, label %cond_true583.i1333, label %cond_next592.i1337 + +cond_true583.i1333: ; preds = %cond_true541.i1317 + br bool false, label %cond_true586.i1335, label %cond_next592.i1337 + +cond_true586.i1335: ; preds = %cond_true583.i1333 + br label %cond_true.i + +cond_next592.i1337: ; preds = %cond_true583.i1333, %cond_true541.i1317 + %mask_z.0.i1339 = phi uint [ %tmp18.i1026, %cond_true541.i1317 ], [ 0, %cond_true583.i1333 ] ; <uint> [#uses=0] + %tmp594.i1340 = and uint %tmp545.i1318, 15 ; <uint> [#uses=0] + br label %cond_true.i + +cond_false1148.i1653: ; preds = %bb377.i1259, %bb38.i + %tmp1150.i1654 = seteq uint %tmp7.i1021, 0 ; <bool> [#uses=1] + %tmp1160.i1656 = seteq ubyte %tmp18.i1027, 0 ; <bool> [#uses=1] + %bothcond8.i1658 = or bool %tmp1150.i1654, %tmp1160.i1656 ; <bool> [#uses=1] + %bothcond9.i1659 = or bool %bothcond8.i1658, false ; <bool> [#uses=0] + br label %cond_true.i + +cond_true.i: ; preds = %cond_false1148.i1653, %cond_next592.i1337, %cond_true586.i1335 + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2006-05-06-Infloop.ll b/llvm/test/Transforms/InstCombine/2006-05-06-Infloop.ll new file mode 100644 index 00000000000..ef05e6b3542 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-05-06-Infloop.ll @@ -0,0 +1,522 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + + %struct.gs_matrix = type { float, int, float, int, float, int, float, int, float, int, float, int } + %struct.gx_bitmap = type { ubyte*, int, int, int } + %struct.gx_device = type { int, %struct.gx_device_procs*, sbyte*, int, int, float, float, int, ushort, int, int } + %struct.gx_device_memory = type { int, %struct.gx_device_procs*, sbyte*, int, int, float, float, int, ushort, int, int, %struct.gs_matrix, int, ubyte*, ubyte**, int (%struct.gx_device_memory*, int, int, int, int, int)*, int, int, ubyte* } + %struct.gx_device_procs = type { int (%struct.gx_device*)*, void (%struct.gx_device*, %struct.gs_matrix*)*, int (%struct.gx_device*)*, int (%struct.gx_device*)*, int (%struct.gx_device*)*, uint (%struct.gx_device*, ushort, ushort, ushort)*, int (%struct.gx_device*, uint, ushort*)*, int (%struct.gx_device*, int, int, int, int, uint)*, int (%struct.gx_device*, %struct.gx_bitmap*, int, int, int, int, uint, uint)*, int (%struct.gx_device*, ubyte*, int, int, int, int, int, int, uint, uint)*, int (%struct.gx_device*, ubyte*, int, int, int, int, int, int)*, int (%struct.gx_device*, int, int, int, int, uint)*, int (%struct.gx_device*, int, int, int, int, int, int, uint)*, int (%struct.gx_device*, %struct.gx_bitmap*, int, int, int, int, int, int, uint, uint)* } + +implementation ; Functions: + +int %mem_mono_copy_mono(%struct.gx_device* %dev, ubyte* %base, int %sourcex, int %raster, int %x, int %y, int %w, int %h, uint %zero, uint %one) { +entry: + %raster = cast int %raster to uint ; <uint> [#uses=3] + %tmp = seteq uint %one, %zero ; <bool> [#uses=1] + br bool %tmp, label %cond_true, label %cond_next + +cond_true: ; preds = %entry + %tmp6 = tail call int %mem_mono_fill_rectangle( %struct.gx_device* %dev, int %x, int %y, int %w, int %h, uint %zero ) ; <int> [#uses=1] + ret int %tmp6 + +cond_next: ; preds = %entry + %tmp8 = cast %struct.gx_device* %dev to %struct.gx_device_memory* ; <%struct.gx_device_memory*> [#uses=6] + %tmp = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 15 ; <int (%struct.gx_device_memory*, int, int, int, int, int)**> [#uses=1] + %tmp = load int (%struct.gx_device_memory*, int, int, int, int, int)** %tmp ; <int (%struct.gx_device_memory*, int, int, int, int, int)*> [#uses=2] + %tmp9 = seteq int (%struct.gx_device_memory*, int, int, int, int, int)* %tmp, %mem_no_fault_proc ; <bool> [#uses=1] + br bool %tmp9, label %cond_next46, label %cond_true10 + +cond_true10: ; preds = %cond_next + %tmp16 = add int %x, 7 ; <int> [#uses=1] + %tmp17 = add int %tmp16, %w ; <int> [#uses=1] + %tmp18 = shr int %tmp17, ubyte 3 ; <int> [#uses=1] + %tmp20 = shr int %x, ubyte 3 ; <int> [#uses=2] + %tmp21 = sub int %tmp18, %tmp20 ; <int> [#uses=1] + %tmp27 = tail call int %tmp( %struct.gx_device_memory* %tmp8, int %tmp20, int %y, int %tmp21, int %h, int 1 ) ; <int> [#uses=2] + %tmp29 = setlt int %tmp27, 0 ; <bool> [#uses=1] + br bool %tmp29, label %cond_true30, label %cond_next46 + +cond_true30: ; preds = %cond_true10 + %tmp41 = tail call int %mem_copy_mono_recover( %struct.gx_device* %dev, ubyte* %base, int %sourcex, int %raster, int %x, int %y, int %w, int %h, uint %zero, uint %one, int %tmp27 ) ; <int> [#uses=1] + ret int %tmp41 + +cond_next46: ; preds = %cond_true10, %cond_next + %tmp48 = setgt int %w, 0 ; <bool> [#uses=1] + %tmp53 = setgt int %h, 0 ; <bool> [#uses=1] + %bothcond = and bool %tmp53, %tmp48 ; <bool> [#uses=1] + br bool %bothcond, label %bb58, label %return + +bb58: ; preds = %cond_next46 + %tmp60 = setlt int %x, 0 ; <bool> [#uses=1] + br bool %tmp60, label %return, label %cond_next63 + +cond_next63: ; preds = %bb58 + %tmp65 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 3 ; <int*> [#uses=1] + %tmp66 = load int* %tmp65 ; <int> [#uses=1] + %tmp68 = sub int %tmp66, %w ; <int> [#uses=1] + %tmp70 = setlt int %tmp68, %x ; <bool> [#uses=1] + %tmp75 = setlt int %y, 0 ; <bool> [#uses=1] + %bothcond1 = or bool %tmp70, %tmp75 ; <bool> [#uses=1] + br bool %bothcond1, label %return, label %cond_next78 + +cond_next78: ; preds = %cond_next63 + %tmp80 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 4 ; <int*> [#uses=1] + %tmp81 = load int* %tmp80 ; <int> [#uses=1] + %tmp83 = sub int %tmp81, %h ; <int> [#uses=1] + %tmp85 = setlt int %tmp83, %y ; <bool> [#uses=1] + br bool %tmp85, label %return, label %bb91 + +bb91: ; preds = %cond_next78 + %tmp93 = shr int %x, ubyte 3 ; <int> [#uses=4] + %tmp = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 14 ; <ubyte***> [#uses=1] + %tmp = load ubyte*** %tmp ; <ubyte**> [#uses=1] + %tmp96 = getelementptr ubyte** %tmp, int %y ; <ubyte**> [#uses=4] + %tmp98 = load ubyte** %tmp96 ; <ubyte*> [#uses=1] + %tmp100 = getelementptr ubyte* %tmp98, int %tmp93 ; <ubyte*> [#uses=3] + %tmp102 = shr int %sourcex, ubyte 3 ; <int> [#uses=3] + %tmp106 = and int %sourcex, 7 ; <int> [#uses=1] + %tmp107 = sub int 8, %tmp106 ; <int> [#uses=4] + %tmp109 = and int %x, 7 ; <int> [#uses=3] + %tmp110 = sub int 8, %tmp109 ; <int> [#uses=8] + %tmp112 = sub int 8, %tmp110 ; <int> [#uses=1] + %tmp112 = cast int %tmp112 to ubyte ; <ubyte> [#uses=1] + %tmp113464 = shr uint 255, ubyte %tmp112 ; <uint> [#uses=4] + %tmp116 = setgt int %tmp110, %w ; <bool> [#uses=1] + %tmp132 = getelementptr %struct.gx_device_memory* %tmp8, int 0, uint 16 ; <int*> [#uses=2] + br bool %tmp116, label %cond_true117, label %cond_false123 + +cond_true117: ; preds = %bb91 + %tmp119 = cast int %w to ubyte ; <ubyte> [#uses=1] + %tmp120 = shr uint %tmp113464, ubyte %tmp119 ; <uint> [#uses=1] + %tmp122 = sub uint %tmp113464, %tmp120 ; <uint> [#uses=2] + %tmp13315 = load int* %tmp132 ; <int> [#uses=1] + %tmp13416 = seteq int %tmp13315, 0 ; <bool> [#uses=1] + br bool %tmp13416, label %cond_next151, label %cond_true135 + +cond_false123: ; preds = %bb91 + %tmp126 = sub int %w, %tmp110 ; <int> [#uses=1] + %tmp126 = cast int %tmp126 to ubyte ; <ubyte> [#uses=1] + %tmp127 = and ubyte %tmp126, 7 ; <ubyte> [#uses=1] + %tmp128 = shr uint 255, ubyte %tmp127 ; <uint> [#uses=1] + %tmp1295 = sub uint 255, %tmp128 ; <uint> [#uses=2] + %tmp133 = load int* %tmp132 ; <int> [#uses=1] + %tmp134 = seteq int %tmp133, 0 ; <bool> [#uses=1] + br bool %tmp134, label %cond_next151, label %cond_true135 + +cond_true135: ; preds = %cond_false123, %cond_true117 + %rmask.0.0 = phi uint [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ] ; <uint> [#uses=2] + %mask.1.0 = phi uint [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ] ; <uint> [#uses=2] + %not.tmp137 = setne uint %zero, 4294967295 ; <bool> [#uses=1] + %tmp140 = cast bool %not.tmp137 to uint ; <uint> [#uses=1] + %zero_addr.0 = xor uint %tmp140, %zero ; <uint> [#uses=2] + %tmp144 = seteq uint %one, 4294967295 ; <bool> [#uses=1] + br bool %tmp144, label %cond_next151, label %cond_true145 + +cond_true145: ; preds = %cond_true135 + %tmp147 = xor uint %one, 1 ; <uint> [#uses=1] + br label %cond_next151 + +cond_next151: ; preds = %cond_true145, %cond_true135, %cond_false123, %cond_true117 + %rmask.0.1 = phi uint [ %rmask.0.0, %cond_true145 ], [ undef, %cond_true117 ], [ %tmp1295, %cond_false123 ], [ %rmask.0.0, %cond_true135 ] ; <uint> [#uses=4] + %mask.1.1 = phi uint [ %mask.1.0, %cond_true145 ], [ %tmp122, %cond_true117 ], [ %tmp113464, %cond_false123 ], [ %mask.1.0, %cond_true135 ] ; <uint> [#uses=4] + %one_addr.0 = phi uint [ %tmp147, %cond_true145 ], [ %one, %cond_true117 ], [ %one, %cond_false123 ], [ %one, %cond_true135 ] ; <uint> [#uses=2] + %zero_addr.1 = phi uint [ %zero_addr.0, %cond_true145 ], [ %zero, %cond_true117 ], [ %zero, %cond_false123 ], [ %zero_addr.0, %cond_true135 ] ; <uint> [#uses=2] + %tmp153 = seteq uint %zero_addr.1, 1 ; <bool> [#uses=2] + %tmp158 = seteq uint %one_addr.0, 0 ; <bool> [#uses=2] + %bothcond2 = or bool %tmp153, %tmp158 ; <bool> [#uses=1] + %iftmp.35.0 = select bool %bothcond2, uint 4294967295, uint 0 ; <uint> [#uses=8] + %tmp167 = seteq uint %zero_addr.1, 0 ; <bool> [#uses=1] + %bothcond3 = or bool %tmp167, %tmp158 ; <bool> [#uses=1] + %iftmp.36.0 = select bool %bothcond3, uint 0, uint 4294967295 ; <uint> [#uses=4] + %tmp186 = seteq uint %one_addr.0, 1 ; <bool> [#uses=1] + %bothcond4 = or bool %tmp153, %tmp186 ; <bool> [#uses=1] + %iftmp.37.0 = select bool %bothcond4, uint 4294967295, uint 0 ; <uint> [#uses=6] + %tmp196 = seteq int %tmp107, %tmp110 ; <bool> [#uses=1] + br bool %tmp196, label %cond_true197, label %cond_false299 + +cond_true197: ; preds = %cond_next151 + %tmp29222 = add int %h, -1 ; <int> [#uses=3] + %tmp29424 = setlt int %tmp29222, 0 ; <bool> [#uses=1] + br bool %tmp29424, label %return, label %cond_true295.preheader + +cond_true249.preheader: ; preds = %cond_true295 + br label %cond_true249 + +cond_true249: ; preds = %cond_true249, %cond_true249.preheader + %indvar = phi uint [ 0, %cond_true249.preheader ], [ %indvar.next, %cond_true249 ] ; <uint> [#uses=2] + %optr.3.2 = phi ubyte* [ %tmp232, %cond_true249 ], [ %dest.1.0, %cond_true249.preheader ] ; <ubyte*> [#uses=1] + %bptr.3.2 = phi ubyte* [ %tmp226, %cond_true249 ], [ %line.1.0, %cond_true249.preheader ] ; <ubyte*> [#uses=1] + %tmp. = add int %tmp109, %w ; <int> [#uses=1] + %indvar = cast uint %indvar to int ; <int> [#uses=1] + %tmp.58 = mul int %indvar, -8 ; <int> [#uses=1] + %tmp.57 = add int %tmp., -16 ; <int> [#uses=1] + %tmp246.2 = add int %tmp.58, %tmp.57 ; <int> [#uses=1] + %tmp225 = cast ubyte* %bptr.3.2 to uint ; <uint> [#uses=1] + %tmp226 = add uint %tmp225, 1 ; <uint> [#uses=1] + %tmp226 = cast uint %tmp226 to ubyte* ; <ubyte*> [#uses=3] + %tmp228 = load ubyte* %tmp226 ; <ubyte> [#uses=1] + %tmp228 = cast ubyte %tmp228 to uint ; <uint> [#uses=1] + %tmp230 = xor uint %tmp228, %iftmp.35.0 ; <uint> [#uses=2] + %tmp231 = cast ubyte* %optr.3.2 to uint ; <uint> [#uses=1] + %tmp232 = add uint %tmp231, 1 ; <uint> [#uses=1] + %tmp232 = cast uint %tmp232 to ubyte* ; <ubyte*> [#uses=4] + %tmp235 = or uint %tmp230, %iftmp.36.0 ; <uint> [#uses=1] + %tmp235 = cast uint %tmp235 to ubyte ; <ubyte> [#uses=1] + %tmp237 = load ubyte* %tmp232 ; <ubyte> [#uses=1] + %tmp238 = and ubyte %tmp235, %tmp237 ; <ubyte> [#uses=1] + %tmp241 = and uint %tmp230, %iftmp.37.0 ; <uint> [#uses=1] + %tmp241 = cast uint %tmp241 to ubyte ; <ubyte> [#uses=1] + %tmp242 = or ubyte %tmp238, %tmp241 ; <ubyte> [#uses=1] + store ubyte %tmp242, ubyte* %tmp232 + %tmp24629 = add int %tmp246.2, -8 ; <int> [#uses=2] + %tmp24831 = setlt int %tmp24629, 0 ; <bool> [#uses=1] + %indvar.next = add uint %indvar, 1 ; <uint> [#uses=1] + br bool %tmp24831, label %bb252.loopexit, label %cond_true249 + +bb252.loopexit: ; preds = %cond_true249 + br label %bb252 + +bb252: ; preds = %cond_true295, %bb252.loopexit + %optr.3.3 = phi ubyte* [ %dest.1.0, %cond_true295 ], [ %tmp232, %bb252.loopexit ] ; <ubyte*> [#uses=1] + %bptr.3.3 = phi ubyte* [ %line.1.0, %cond_true295 ], [ %tmp226, %bb252.loopexit ] ; <ubyte*> [#uses=1] + %tmp246.3 = phi int [ %tmp246, %cond_true295 ], [ %tmp24629, %bb252.loopexit ] ; <int> [#uses=1] + %tmp254 = setgt int %tmp246.3, -8 ; <bool> [#uses=1] + br bool %tmp254, label %cond_true255, label %cond_next280 + +cond_true255: ; preds = %bb252 + %tmp256 = cast ubyte* %bptr.3.3 to uint ; <uint> [#uses=1] + %tmp257 = add uint %tmp256, 1 ; <uint> [#uses=1] + %tmp257 = cast uint %tmp257 to ubyte* ; <ubyte*> [#uses=1] + %tmp259 = load ubyte* %tmp257 ; <ubyte> [#uses=1] + %tmp259 = cast ubyte %tmp259 to uint ; <uint> [#uses=1] + %tmp261 = xor uint %tmp259, %iftmp.35.0 ; <uint> [#uses=2] + %tmp262 = cast ubyte* %optr.3.3 to uint ; <uint> [#uses=1] + %tmp263 = add uint %tmp262, 1 ; <uint> [#uses=1] + %tmp263 = cast uint %tmp263 to ubyte* ; <ubyte*> [#uses=2] + %tmp265 = cast uint %tmp261 to ubyte ; <ubyte> [#uses=1] + %tmp268 = or ubyte %tmp266, %tmp265 ; <ubyte> [#uses=1] + %tmp270 = load ubyte* %tmp263 ; <ubyte> [#uses=1] + %tmp271 = and ubyte %tmp268, %tmp270 ; <ubyte> [#uses=1] + %tmp276 = and uint %tmp274, %tmp261 ; <uint> [#uses=1] + %tmp276 = cast uint %tmp276 to ubyte ; <ubyte> [#uses=1] + %tmp277 = or ubyte %tmp271, %tmp276 ; <ubyte> [#uses=1] + store ubyte %tmp277, ubyte* %tmp263 + br label %cond_next280 + +cond_next280: ; preds = %cond_true255, %bb252 + %tmp281 = cast ubyte** %dest_line.1.0 to uint ; <uint> [#uses=1] + %tmp282 = add uint %tmp281, 4 ; <uint> [#uses=1] + %tmp282 = cast uint %tmp282 to ubyte** ; <ubyte**> [#uses=2] + %tmp284 = load ubyte** %tmp282 ; <ubyte*> [#uses=1] + %tmp286 = getelementptr ubyte* %tmp284, int %tmp93 ; <ubyte*> [#uses=1] + %tmp292 = add int %tmp292.0, -1 ; <int> [#uses=1] + %tmp294 = setlt int %tmp292, 0 ; <bool> [#uses=1] + %indvar.next61 = add uint %indvar60, 1 ; <uint> [#uses=1] + br bool %tmp294, label %return.loopexit, label %cond_true295 + +cond_true295.preheader: ; preds = %cond_true197 + %tmp200 = sub int %w, %tmp110 ; <int> [#uses=1] + %tmp209 = cast uint %mask.1.1 to ubyte ; <ubyte> [#uses=1] + %tmp209not = xor ubyte %tmp209, 255 ; <ubyte> [#uses=1] + %tmp212 = cast uint %iftmp.36.0 to ubyte ; <ubyte> [#uses=2] + %tmp211 = or ubyte %tmp212, %tmp209not ; <ubyte> [#uses=2] + %tmp219 = and uint %iftmp.37.0, %mask.1.1 ; <uint> [#uses=2] + %tmp246 = add int %tmp200, -8 ; <int> [#uses=3] + %tmp248 = setlt int %tmp246, 0 ; <bool> [#uses=1] + %tmp264 = cast uint %rmask.0.1 to ubyte ; <ubyte> [#uses=1] + %tmp264not = xor ubyte %tmp264, 255 ; <ubyte> [#uses=1] + %tmp266 = or ubyte %tmp212, %tmp264not ; <ubyte> [#uses=2] + %tmp274 = and uint %iftmp.37.0, %rmask.0.1 ; <uint> [#uses=2] + br bool %tmp248, label %cond_true295.preheader.split.us, label %cond_true295.preheader.split + +cond_true295.preheader.split.us: ; preds = %cond_true295.preheader + br label %cond_true295.us + +cond_true295.us: ; preds = %cond_next280.us, %cond_true295.preheader.split.us + %indvar86 = phi uint [ 0, %cond_true295.preheader.split.us ], [ %indvar.next87, %cond_next280.us ] ; <uint> [#uses=3] + %dest.1.0.us = phi ubyte* [ %tmp286.us, %cond_next280.us ], [ %tmp100, %cond_true295.preheader.split.us ] ; <ubyte*> [#uses=3] + %dest_line.1.0.us = phi ubyte** [ %tmp282.us, %cond_next280.us ], [ %tmp96, %cond_true295.preheader.split.us ] ; <ubyte**> [#uses=1] + %tmp.89 = sub uint 0, %indvar86 ; <uint> [#uses=1] + %tmp.89 = cast uint %tmp.89 to int ; <int> [#uses=1] + %tmp292.0.us = add int %tmp.89, %tmp29222 ; <int> [#uses=1] + %tmp.91 = mul uint %indvar86, %raster ; <uint> [#uses=1] + %tmp.91 = cast uint %tmp.91 to int ; <int> [#uses=1] + %tmp104.sum101 = add int %tmp102, %tmp.91 ; <int> [#uses=1] + %line.1.0.us = getelementptr ubyte* %base, int %tmp104.sum101 ; <ubyte*> [#uses=2] + %tmp.us = load ubyte* %line.1.0.us ; <ubyte> [#uses=1] + %tmp206.us = cast ubyte %tmp.us to uint ; <uint> [#uses=1] + %tmp208.us = xor uint %tmp206.us, %iftmp.35.0 ; <uint> [#uses=2] + %tmp210.us = cast uint %tmp208.us to ubyte ; <ubyte> [#uses=1] + %tmp213.us = or ubyte %tmp211, %tmp210.us ; <ubyte> [#uses=1] + %tmp215.us = load ubyte* %dest.1.0.us ; <ubyte> [#uses=1] + %tmp216.us = and ubyte %tmp213.us, %tmp215.us ; <ubyte> [#uses=1] + %tmp221.us = and uint %tmp219, %tmp208.us ; <uint> [#uses=1] + %tmp221.us = cast uint %tmp221.us to ubyte ; <ubyte> [#uses=1] + %tmp222.us = or ubyte %tmp216.us, %tmp221.us ; <ubyte> [#uses=1] + store ubyte %tmp222.us, ubyte* %dest.1.0.us + br bool true, label %bb252.us, label %cond_true249.preheader.us + +cond_next280.us: ; preds = %bb252.us, %cond_true255.us + %tmp281.us = cast ubyte** %dest_line.1.0.us to uint ; <uint> [#uses=1] + %tmp282.us = add uint %tmp281.us, 4 ; <uint> [#uses=1] + %tmp282.us = cast uint %tmp282.us to ubyte** ; <ubyte**> [#uses=2] + %tmp284.us = load ubyte** %tmp282.us ; <ubyte*> [#uses=1] + %tmp286.us = getelementptr ubyte* %tmp284.us, int %tmp93 ; <ubyte*> [#uses=1] + %tmp292.us = add int %tmp292.0.us, -1 ; <int> [#uses=1] + %tmp294.us = setlt int %tmp292.us, 0 ; <bool> [#uses=1] + %indvar.next87 = add uint %indvar86, 1 ; <uint> [#uses=1] + br bool %tmp294.us, label %return.loopexit.us, label %cond_true295.us + +cond_true255.us: ; preds = %bb252.us + %tmp256.us = cast ubyte* %bptr.3.3.us to uint ; <uint> [#uses=1] + %tmp257.us = add uint %tmp256.us, 1 ; <uint> [#uses=1] + %tmp257.us = cast uint %tmp257.us to ubyte* ; <ubyte*> [#uses=1] + %tmp259.us = load ubyte* %tmp257.us ; <ubyte> [#uses=1] + %tmp259.us = cast ubyte %tmp259.us to uint ; <uint> [#uses=1] + %tmp261.us = xor uint %tmp259.us, %iftmp.35.0 ; <uint> [#uses=2] + %tmp262.us = cast ubyte* %optr.3.3.us to uint ; <uint> [#uses=1] + %tmp263.us = add uint %tmp262.us, 1 ; <uint> [#uses=1] + %tmp263.us = cast uint %tmp263.us to ubyte* ; <ubyte*> [#uses=2] + %tmp265.us = cast uint %tmp261.us to ubyte ; <ubyte> [#uses=1] + %tmp268.us = or ubyte %tmp266, %tmp265.us ; <ubyte> [#uses=1] + %tmp270.us = load ubyte* %tmp263.us ; <ubyte> [#uses=1] + %tmp271.us = and ubyte %tmp268.us, %tmp270.us ; <ubyte> [#uses=1] + %tmp276.us = and uint %tmp274, %tmp261.us ; <uint> [#uses=1] + %tmp276.us = cast uint %tmp276.us to ubyte ; <ubyte> [#uses=1] + %tmp277.us = or ubyte %tmp271.us, %tmp276.us ; <ubyte> [#uses=1] + store ubyte %tmp277.us, ubyte* %tmp263.us + br label %cond_next280.us + +bb252.us: ; preds = %bb252.loopexit.us, %cond_true295.us + %optr.3.3.us = phi ubyte* [ %dest.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ] ; <ubyte*> [#uses=1] + %bptr.3.3.us = phi ubyte* [ %line.1.0.us, %cond_true295.us ], [ undef, %bb252.loopexit.us ] ; <ubyte*> [#uses=1] + %tmp246.3.us = phi int [ %tmp246, %cond_true295.us ], [ undef, %bb252.loopexit.us ] ; <int> [#uses=1] + %tmp254.us = setgt int %tmp246.3.us, -8 ; <bool> [#uses=1] + br bool %tmp254.us, label %cond_true255.us, label %cond_next280.us + +cond_true249.us: ; preds = %cond_true249.preheader.us, %cond_true249.us + br bool undef, label %bb252.loopexit.us, label %cond_true249.us + +cond_true249.preheader.us: ; preds = %cond_true295.us + br label %cond_true249.us + +bb252.loopexit.us: ; preds = %cond_true249.us + br label %bb252.us + +return.loopexit.us: ; preds = %cond_next280.us + br label %return.loopexit.split + +cond_true295.preheader.split: ; preds = %cond_true295.preheader + br label %cond_true295 + +cond_true295: ; preds = %cond_true295.preheader.split, %cond_next280 + %indvar60 = phi uint [ 0, %cond_true295.preheader.split ], [ %indvar.next61, %cond_next280 ] ; <uint> [#uses=3] + %dest.1.0 = phi ubyte* [ %tmp286, %cond_next280 ], [ %tmp100, %cond_true295.preheader.split ] ; <ubyte*> [#uses=4] + %dest_line.1.0 = phi ubyte** [ %tmp282, %cond_next280 ], [ %tmp96, %cond_true295.preheader.split ] ; <ubyte**> [#uses=1] + %tmp.63 = sub uint 0, %indvar60 ; <uint> [#uses=1] + %tmp.63 = cast uint %tmp.63 to int ; <int> [#uses=1] + %tmp292.0 = add int %tmp.63, %tmp29222 ; <int> [#uses=1] + %tmp.65 = mul uint %indvar60, %raster ; <uint> [#uses=1] + %tmp.65 = cast uint %tmp.65 to int ; <int> [#uses=1] + %tmp104.sum97 = add int %tmp102, %tmp.65 ; <int> [#uses=1] + %line.1.0 = getelementptr ubyte* %base, int %tmp104.sum97 ; <ubyte*> [#uses=3] + %tmp = load ubyte* %line.1.0 ; <ubyte> [#uses=1] + %tmp206 = cast ubyte %tmp to uint ; <uint> [#uses=1] + %tmp208 = xor uint %tmp206, %iftmp.35.0 ; <uint> [#uses=2] + %tmp210 = cast uint %tmp208 to ubyte ; <ubyte> [#uses=1] + %tmp213 = or ubyte %tmp211, %tmp210 ; <ubyte> [#uses=1] + %tmp215 = load ubyte* %dest.1.0 ; <ubyte> [#uses=1] + %tmp216 = and ubyte %tmp213, %tmp215 ; <ubyte> [#uses=1] + %tmp221 = and uint %tmp219, %tmp208 ; <uint> [#uses=1] + %tmp221 = cast uint %tmp221 to ubyte ; <ubyte> [#uses=1] + %tmp222 = or ubyte %tmp216, %tmp221 ; <ubyte> [#uses=1] + store ubyte %tmp222, ubyte* %dest.1.0 + br bool false, label %bb252, label %cond_true249.preheader + +cond_false299: ; preds = %cond_next151 + %tmp302 = sub int %tmp107, %tmp110 ; <int> [#uses=1] + %tmp303 = and int %tmp302, 7 ; <int> [#uses=3] + %tmp305 = sub int 8, %tmp303 ; <int> [#uses=1] + %tmp45438 = add int %h, -1 ; <int> [#uses=2] + %tmp45640 = setlt int %tmp45438, 0 ; <bool> [#uses=1] + br bool %tmp45640, label %return, label %cond_true457.preheader + +cond_true316: ; preds = %cond_true457 + %tmp318 = cast ubyte %tmp318 to uint ; <uint> [#uses=1] + %tmp320 = shr uint %tmp318, ubyte %tmp319 ; <uint> [#uses=1] + br label %cond_next340 + +cond_false321: ; preds = %cond_true457 + %tmp3188 = cast ubyte %tmp318 to uint ; <uint> [#uses=1] + %tmp325 = shl uint %tmp3188, ubyte %tmp324 ; <uint> [#uses=2] + %tmp326 = cast ubyte* %line.3.0 to uint ; <uint> [#uses=1] + %tmp327 = add uint %tmp326, 1 ; <uint> [#uses=1] + %tmp327 = cast uint %tmp327 to ubyte* ; <ubyte*> [#uses=3] + br bool %tmp330, label %cond_true331, label %cond_next340 + +cond_true331: ; preds = %cond_false321 + %tmp333 = load ubyte* %tmp327 ; <ubyte> [#uses=1] + %tmp333 = cast ubyte %tmp333 to uint ; <uint> [#uses=1] + %tmp335 = shr uint %tmp333, ubyte %tmp319 ; <uint> [#uses=1] + %tmp337 = add uint %tmp335, %tmp325 ; <uint> [#uses=1] + br label %cond_next340 + +cond_next340: ; preds = %cond_true331, %cond_false321, %cond_true316 + %bits.0 = phi uint [ %tmp320, %cond_true316 ], [ %tmp337, %cond_true331 ], [ %tmp325, %cond_false321 ] ; <uint> [#uses=1] + %bptr307.3 = phi ubyte* [ %line.3.0, %cond_true316 ], [ %tmp327, %cond_true331 ], [ %tmp327, %cond_false321 ] ; <ubyte*> [#uses=2] + %tmp343 = xor uint %bits.0, %iftmp.35.0 ; <uint> [#uses=2] + %tmp345 = cast uint %tmp343 to ubyte ; <ubyte> [#uses=1] + %tmp348 = or ubyte %tmp346, %tmp345 ; <ubyte> [#uses=1] + %tmp350 = load ubyte* %dest.3.0 ; <ubyte> [#uses=1] + %tmp351 = and ubyte %tmp348, %tmp350 ; <ubyte> [#uses=1] + %tmp356 = and uint %tmp354, %tmp343 ; <uint> [#uses=1] + %tmp356 = cast uint %tmp356 to ubyte ; <ubyte> [#uses=1] + %tmp357 = or ubyte %tmp351, %tmp356 ; <ubyte> [#uses=1] + store ubyte %tmp357, ubyte* %dest.3.0 + %tmp362 = cast ubyte* %dest.3.0 to uint ; <uint> [#uses=1] + %optr309.3.in51 = add uint %tmp362, 1 ; <uint> [#uses=2] + %optr309.353 = cast uint %optr309.3.in51 to ubyte* ; <ubyte*> [#uses=2] + br bool %tmp39755, label %cond_true398.preheader, label %bb401 + +cond_true398.preheader: ; preds = %cond_next340 + br label %cond_true398 + +cond_true398: ; preds = %cond_true398, %cond_true398.preheader + %indvar66 = phi uint [ 0, %cond_true398.preheader ], [ %indvar.next67, %cond_true398 ] ; <uint> [#uses=3] + %bptr307.4.0 = phi ubyte* [ %tmp370, %cond_true398 ], [ %bptr307.3, %cond_true398.preheader ] ; <ubyte*> [#uses=2] + %optr309.3.0 = phi ubyte* [ %optr309.3, %cond_true398 ], [ %optr309.353, %cond_true398.preheader ] ; <ubyte*> [#uses=2] + %optr309.3.in.0 = add uint %indvar66, %optr309.3.in51 ; <uint> [#uses=1] + %tmp.70 = add int %tmp109, %w ; <int> [#uses=1] + %indvar66 = cast uint %indvar66 to int ; <int> [#uses=1] + %tmp.72 = mul int %indvar66, -8 ; <int> [#uses=1] + %tmp.71 = add int %tmp.70, -8 ; <int> [#uses=1] + %count308.3.0 = add int %tmp.72, %tmp.71 ; <int> [#uses=1] + %tmp366 = load ubyte* %bptr307.4.0 ; <ubyte> [#uses=1] + %tmp366 = cast ubyte %tmp366 to uint ; <uint> [#uses=1] + %tmp369 = cast ubyte* %bptr307.4.0 to uint ; <uint> [#uses=1] + %tmp370 = add uint %tmp369, 1 ; <uint> [#uses=1] + %tmp370 = cast uint %tmp370 to ubyte* ; <ubyte*> [#uses=3] + %tmp372 = load ubyte* %tmp370 ; <ubyte> [#uses=1] + %tmp372 = cast ubyte %tmp372 to uint ; <uint> [#uses=1] + %tmp374463 = shr uint %tmp372, ubyte %tmp319 ; <uint> [#uses=1] + %tmp368 = shl uint %tmp366, ubyte %tmp324 ; <uint> [#uses=1] + %tmp377 = add uint %tmp374463, %tmp368 ; <uint> [#uses=1] + %tmp379 = xor uint %tmp377, %iftmp.35.0 ; <uint> [#uses=2] + %tmp382 = or uint %tmp379, %iftmp.36.0 ; <uint> [#uses=1] + %tmp382 = cast uint %tmp382 to ubyte ; <ubyte> [#uses=1] + %tmp384 = load ubyte* %optr309.3.0 ; <ubyte> [#uses=1] + %tmp385 = and ubyte %tmp382, %tmp384 ; <ubyte> [#uses=1] + %tmp388 = and uint %tmp379, %iftmp.37.0 ; <uint> [#uses=1] + %tmp388 = cast uint %tmp388 to ubyte ; <ubyte> [#uses=1] + %tmp389 = or ubyte %tmp385, %tmp388 ; <ubyte> [#uses=1] + store ubyte %tmp389, ubyte* %optr309.3.0 + %tmp392 = add int %count308.3.0, -8 ; <int> [#uses=2] + %optr309.3.in = add uint %optr309.3.in.0, 1 ; <uint> [#uses=1] + %optr309.3 = cast uint %optr309.3.in to ubyte* ; <ubyte*> [#uses=2] + %tmp397 = setgt int %tmp392, 7 ; <bool> [#uses=1] + %indvar.next67 = add uint %indvar66, 1 ; <uint> [#uses=1] + br bool %tmp397, label %cond_true398, label %bb401.loopexit + +bb401.loopexit: ; preds = %cond_true398 + br label %bb401 + +bb401: ; preds = %bb401.loopexit, %cond_next340 + %count308.3.1 = phi int [ %tmp361, %cond_next340 ], [ %tmp392, %bb401.loopexit ] ; <int> [#uses=2] + %bptr307.4.1 = phi ubyte* [ %bptr307.3, %cond_next340 ], [ %tmp370, %bb401.loopexit ] ; <ubyte*> [#uses=2] + %optr309.3.1 = phi ubyte* [ %optr309.353, %cond_next340 ], [ %optr309.3, %bb401.loopexit ] ; <ubyte*> [#uses=2] + %tmp403 = setgt int %count308.3.1, 0 ; <bool> [#uses=1] + br bool %tmp403, label %cond_true404, label %cond_next442 + +cond_true404: ; preds = %bb401 + %tmp406 = load ubyte* %bptr307.4.1 ; <ubyte> [#uses=1] + %tmp406 = cast ubyte %tmp406 to int ; <int> [#uses=1] + %tmp408 = shl int %tmp406, ubyte %tmp324 ; <int> [#uses=2] + %tmp413 = setgt int %count308.3.1, %tmp303 ; <bool> [#uses=1] + br bool %tmp413, label %cond_true414, label %cond_next422 + +cond_true414: ; preds = %cond_true404 + %tmp409 = cast ubyte* %bptr307.4.1 to uint ; <uint> [#uses=1] + %tmp410 = add uint %tmp409, 1 ; <uint> [#uses=1] + %tmp410 = cast uint %tmp410 to ubyte* ; <ubyte*> [#uses=1] + %tmp416 = load ubyte* %tmp410 ; <ubyte> [#uses=1] + %tmp416 = cast ubyte %tmp416 to uint ; <uint> [#uses=1] + %tmp418 = shr uint %tmp416, ubyte %tmp319 ; <uint> [#uses=1] + %tmp418 = cast uint %tmp418 to int ; <int> [#uses=1] + %tmp420 = add int %tmp418, %tmp408 ; <int> [#uses=1] + br label %cond_next422 + +cond_next422: ; preds = %cond_true414, %cond_true404 + %bits.6 = phi int [ %tmp420, %cond_true414 ], [ %tmp408, %cond_true404 ] ; <int> [#uses=1] + %tmp425 = xor int %bits.6, %iftmp.35.0 ; <int> [#uses=1] + %tmp427 = cast int %tmp425 to ubyte ; <ubyte> [#uses=2] + %tmp430 = or ubyte %tmp428, %tmp427 ; <ubyte> [#uses=1] + %tmp432 = load ubyte* %optr309.3.1 ; <ubyte> [#uses=1] + %tmp433 = and ubyte %tmp430, %tmp432 ; <ubyte> [#uses=1] + %tmp438 = and ubyte %tmp436, %tmp427 ; <ubyte> [#uses=1] + %tmp439 = or ubyte %tmp433, %tmp438 ; <ubyte> [#uses=1] + store ubyte %tmp439, ubyte* %optr309.3.1 + br label %cond_next442 + +cond_next442: ; preds = %cond_next422, %bb401 + %tmp443 = cast ubyte** %dest_line.3.0 to uint ; <uint> [#uses=1] + %tmp444 = add uint %tmp443, 4 ; <uint> [#uses=1] + %tmp444 = cast uint %tmp444 to ubyte** ; <ubyte**> [#uses=2] + %tmp446 = load ubyte** %tmp444 ; <ubyte*> [#uses=1] + %tmp448 = getelementptr ubyte* %tmp446, int %tmp93 ; <ubyte*> [#uses=1] + %tmp454 = add int %tmp454.0, -1 ; <int> [#uses=1] + %tmp456 = setlt int %tmp454, 0 ; <bool> [#uses=1] + %indvar.next75 = add uint %indvar74, 1 ; <uint> [#uses=1] + br bool %tmp456, label %return.loopexit56, label %cond_true457 + +cond_true457.preheader: ; preds = %cond_false299 + %tmp315 = setlt int %tmp107, %tmp110 ; <bool> [#uses=1] + %tmp319 = cast int %tmp303 to ubyte ; <ubyte> [#uses=4] + %tmp324 = cast int %tmp305 to ubyte ; <ubyte> [#uses=3] + %tmp330 = setlt int %tmp107, %w ; <bool> [#uses=1] + %tmp344 = cast uint %mask.1.1 to ubyte ; <ubyte> [#uses=1] + %tmp344not = xor ubyte %tmp344, 255 ; <ubyte> [#uses=1] + %tmp347 = cast uint %iftmp.36.0 to ubyte ; <ubyte> [#uses=2] + %tmp346 = or ubyte %tmp347, %tmp344not ; <ubyte> [#uses=1] + %tmp354 = and uint %iftmp.37.0, %mask.1.1 ; <uint> [#uses=1] + %tmp361 = sub int %w, %tmp110 ; <int> [#uses=2] + %tmp39755 = setgt int %tmp361, 7 ; <bool> [#uses=1] + %iftmp.35.0 = cast uint %iftmp.35.0 to int ; <int> [#uses=1] + %tmp426 = cast uint %rmask.0.1 to ubyte ; <ubyte> [#uses=1] + %tmp426not = xor ubyte %tmp426, 255 ; <ubyte> [#uses=1] + %tmp428 = or ubyte %tmp347, %tmp426not ; <ubyte> [#uses=1] + %tmp436 = and uint %iftmp.37.0, %rmask.0.1 ; <uint> [#uses=1] + %tmp436 = cast uint %tmp436 to ubyte ; <ubyte> [#uses=1] + br label %cond_true457 + +cond_true457: ; preds = %cond_true457.preheader, %cond_next442 + %indvar74 = phi uint [ 0, %cond_true457.preheader ], [ %indvar.next75, %cond_next442 ] ; <uint> [#uses=3] + %dest.3.0 = phi ubyte* [ %tmp448, %cond_next442 ], [ %tmp100, %cond_true457.preheader ] ; <ubyte*> [#uses=3] + %dest_line.3.0 = phi ubyte** [ %tmp444, %cond_next442 ], [ %tmp96, %cond_true457.preheader ] ; <ubyte**> [#uses=1] + %tmp.77 = sub uint 0, %indvar74 ; <uint> [#uses=1] + %tmp.77 = cast uint %tmp.77 to int ; <int> [#uses=1] + %tmp454.0 = add int %tmp.77, %tmp45438 ; <int> [#uses=1] + %tmp.79 = mul uint %indvar74, %raster ; <uint> [#uses=1] + %tmp.79 = cast uint %tmp.79 to int ; <int> [#uses=1] + %tmp104.sum = add int %tmp102, %tmp.79 ; <int> [#uses=1] + %line.3.0 = getelementptr ubyte* %base, int %tmp104.sum ; <ubyte*> [#uses=3] + %tmp318 = load ubyte* %line.3.0 ; <ubyte> [#uses=2] + br bool %tmp315, label %cond_false321, label %cond_true316 + +return.loopexit: ; preds = %cond_next280 + br label %return.loopexit.split + +return.loopexit.split: ; preds = %return.loopexit, %return.loopexit.us + br label %return + +return.loopexit56: ; preds = %cond_next442 + br label %return + +return: ; preds = %return.loopexit56, %return.loopexit.split, %cond_false299, %cond_true197, %cond_next78, %cond_next63, %bb58, %cond_next46 + %retval.0 = phi int [ 0, %cond_next46 ], [ -1, %bb58 ], [ -1, %cond_next63 ], [ -1, %cond_next78 ], [ 0, %cond_true197 ], [ 0, %cond_false299 ], [ 0, %return.loopexit.split ], [ 0, %return.loopexit56 ] ; <int> [#uses=1] + ret int %retval.0 +} + +declare int %mem_no_fault_proc(%struct.gx_device_memory*, int, int, int, int, int) + +declare int %mem_mono_fill_rectangle(%struct.gx_device*, int, int, int, int, uint) + +declare int %mem_copy_mono_recover(%struct.gx_device*, ubyte*, int, int, int, int, int, int, uint, uint, int) diff --git a/llvm/test/Transforms/InstCombine/2006-05-10-InvalidIndexUndef.ll b/llvm/test/Transforms/InstCombine/2006-05-10-InvalidIndexUndef.ll new file mode 100644 index 00000000000..8cdaa5841f8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-05-10-InvalidIndexUndef.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep undef +; XFAIL: * + +%str = constant [4 x ubyte] c"str\00" + +ubyte %main() { + %A = load ubyte* getelementptr ([4 x ubyte]* %str, long 0, long 5) + ret ubyte %A +} diff --git a/llvm/test/Transforms/InstCombine/2006-06-28-infloop.ll b/llvm/test/Transforms/InstCombine/2006-06-28-infloop.ll new file mode 100644 index 00000000000..bd1dbd009c0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-06-28-infloop.ll @@ -0,0 +1,21 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +target endian = big +target pointersize = 32 +target triple = "powerpc-apple-darwin8" + +implementation ; Functions: + +void %test() { +entry: + %tmp = getelementptr { long, long, long, long }* null, int 0, uint 3 + %tmp = load long* %tmp ; <long> [#uses=1] + %tmp8.ui = load ulong* null ; <ulong> [#uses=1] + %tmp8 = cast ulong %tmp8.ui to long ; <long> [#uses=1] + %tmp9 = and long %tmp8, %tmp ; <long> [#uses=1] + %sext = cast long %tmp9 to int ; <int> [#uses=1] + %tmp27.i = cast int %sext to long ; <long> [#uses=1] + tail call void %foo( uint 0, long %tmp27.i ) + unreachable +} + +declare void %foo(uint, long) diff --git a/llvm/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll b/llvm/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll new file mode 100644 index 00000000000..a8f9cd41bad --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-09-11-EmptyStructCrash.ll @@ -0,0 +1,47 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +; PR905 + + %RPYTHON_EXCEPTION = type { %RPYTHON_EXCEPTION_VTABLE* } + %RPYTHON_EXCEPTION_VTABLE = type { %RPYTHON_EXCEPTION_VTABLE*, int, int, %RPyOpaque_RuntimeTypeInfo*, %arraytype_Char*, %functiontype_12* } + %RPyOpaque_RuntimeTypeInfo = type opaque* + %arraytype_Char = type { int, [0 x sbyte] } + %fixarray_array1019 = type [1019 x sbyte*] + %functiontype_12 = type %RPYTHON_EXCEPTION* () + %functiontype_14 = type void (%structtype_pypy.rpython.memory.gc.MarkSweepGC*) + %structtype_AddressLinkedListChunk = type { %structtype_AddressLinkedListChunk*, int, %fixarray_array1019 } + %structtype_exceptions.Exception = type { %RPYTHON_EXCEPTION } + %structtype_gc_pool = type { } + %structtype_gc_pool_node = type { %structtype_header*, %structtype_gc_pool_node* } + %structtype_header = type { int, %structtype_header* } + %structtype_pypy.rpython.memory.gc.MarkSweepGC = type { %structtype_exceptions.Exception, int, int, bool, %structtype_gc_pool*, int, %structtype_header*, %structtype_header*, %structtype_gc_pool_node*, double, double } + +implementation ; Functions: + +fastcc void %pypy_MarkSweepGC.collect() { +block0: + %v1221 = load %structtype_AddressLinkedListChunk** null ; <%structtype_AddressLinkedListChunk*> [#uses=1] + %v1222 = setne %structtype_AddressLinkedListChunk* %v1221, null ; <bool> [#uses=1] + br bool %v1222, label %block79, label %block4 + +block4: ; preds = %block0 + ret void + +block22: ; preds = %block79 + ret void + +block67: ; preds = %block79 + %v1459 = load %structtype_gc_pool** null ; <%structtype_gc_pool*> [#uses=1] + %v1460 = cast %structtype_gc_pool* %v1459 to sbyte* ; <sbyte*> [#uses=1] + %tmp_873 = cast sbyte* %v1460 to int ; <int> [#uses=1] + %tmp_874 = sub int %tmp_873, 0 ; <int> [#uses=1] + %v1461 = cast int %tmp_874 to sbyte* ; <sbyte*> [#uses=1] + %v1462 = cast sbyte* %v1461 to %structtype_header* ; <%structtype_header*> [#uses=1] + %tmp_876 = getelementptr %structtype_header* %v1462, int 0, uint 0 ; <int*> [#uses=1] + store int 0, int* %tmp_876 + ret void + +block79: ; preds = %block0 + %v1291 = load %structtype_gc_pool** null ; <%structtype_gc_pool*> [#uses=1] + %v1292 = setne %structtype_gc_pool* %v1291, null ; <bool> [#uses=1] + br bool %v1292, label %block67, label %block22 +} diff --git a/llvm/test/Transforms/InstCombine/2006-09-15-CastToBool.ll b/llvm/test/Transforms/InstCombine/2006-09-15-CastToBool.ll new file mode 100644 index 00000000000..051d91f91fb --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-09-15-CastToBool.ll @@ -0,0 +1,14 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep and +; PR913 + +int %test(int* %tmp1) { + %tmp.i = load int* %tmp1 ; <int> [#uses=1] + %tmp = cast int %tmp.i to uint ; <uint> [#uses=1] + %tmp2.ui = shr uint %tmp, ubyte 5 ; <uint> [#uses=1] + %tmp2 = cast uint %tmp2.ui to int ; <int> [#uses=1] + %tmp3 = and int %tmp2, 1 ; <int> [#uses=1] + %tmp3 = cast int %tmp3 to bool ; <bool> [#uses=1] + %tmp34 = cast bool %tmp3 to int ; <int> [#uses=1] + ret int %tmp34 +} + diff --git a/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll b/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll new file mode 100644 index 00000000000..89ec03dbbee --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst-2.ll @@ -0,0 +1,9 @@ +; The optimizer should be able to remove cast operation here. +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | not grep 'sext.*i32' + +bool %eq_signed_to_small_unsigned(sbyte %SB) { + %Y = cast sbyte %SB to uint ; <uint> [#uses=1] + %C = seteq uint %Y, 17 ; <bool> [#uses=1] + ret bool %C + } + diff --git a/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll b/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll new file mode 100644 index 00000000000..edd9054f2f5 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-10-19-SignedToUnsignedCastAndConst.ll @@ -0,0 +1,9 @@ +; This test case is reduced from llvmAsmParser.cpp +; The optimizer should not remove the cast here. +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | grep 'sext.*i32' + +bool %test(short %X) { + %A = cast short %X to uint + %B = setgt uint %A, 1330 + ret bool %B +} diff --git a/llvm/test/Transforms/InstCombine/2006-10-20-mask.ll b/llvm/test/Transforms/InstCombine/2006-10-20-mask.ll new file mode 100644 index 00000000000..51855cd9b5d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-10-20-mask.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | grep 'and' +ulong %foo(ulong %tmp, ulong %tmp2) { + %tmp = cast ulong %tmp to uint + %tmp2 = cast ulong %tmp2 to uint + %tmp3 = and uint %tmp, %tmp2 + %tmp4 = cast uint %tmp3 to ulong + ret ulong %tmp4 +} diff --git a/llvm/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll b/llvm/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll new file mode 100644 index 00000000000..a7172b8a09e --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-10-26-VectorReassoc.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep mul | wc -l | grep 2 + + +<4 x float> %test(<4 x float> %V) { + %Y = mul <4 x float> %V, <float 1.0, float 2.0, float 3.0, float 4.0> + %Z = mul <4 x float> %Y, <float 1.0, float 200000.0, float -3.0, float 4.0> + ret <4 x float> %Z +} diff --git a/llvm/test/Transforms/InstCombine/2006-11-03-Memmove64.ll b/llvm/test/Transforms/InstCombine/2006-11-03-Memmove64.ll new file mode 100644 index 00000000000..e863ab86e89 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-11-03-Memmove64.ll @@ -0,0 +1,18 @@ +;RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis |not grep memmove.i32 +; Instcombine was trying to turn this into a memmove.i32 + +target datalayout = "e-p:64:64" +target endian = little +target pointersize = 64 +target triple = "alphaev67-unknown-linux-gnu" +%str10 = internal constant [1 x sbyte] zeroinitializer ; <[1 x sbyte]*> [#uses=1] + +implementation ; Functions: + +void %do_join(sbyte* %b) { +entry: + call void %llvm.memmove.i64( sbyte* %b, sbyte* getelementptr ([1 x sbyte]* %str10, int 0, ulong 0), ulong 1, uint 1 ) + ret void +} + +declare void %llvm.memmove.i64(sbyte*, sbyte*, ulong, uint) diff --git a/llvm/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll b/llvm/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll new file mode 100644 index 00000000000..1809d3ce917 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-11-10-ashr-miscompile.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep lshr +; Verify this is not turned into -1. + +int %test(ubyte %amt) { + %B = lshr int -1, ubyte %amt + ret int %B +} diff --git a/llvm/test/Transforms/InstCombine/2006-11-27-XorBug.ll b/llvm/test/Transforms/InstCombine/2006-11-27-XorBug.ll new file mode 100644 index 00000000000..61501668298 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-11-27-XorBug.ll @@ -0,0 +1,11 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'and.*32' && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'or.*153' +; PR1014 + +int %test(int %tmp1) { + %ovm = and int %tmp1, 32 ; <int> [#uses=1] + %ov3 = add int %ovm, 145 ; <int> [#uses=2] + %ov110 = xor int %ov3, 153 + ret int %ov110 +} + diff --git a/llvm/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll b/llvm/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll new file mode 100644 index 00000000000..54f70746d1d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-01-BadFPVectorXform.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep sub && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep add + +<4 x float> %test(<4 x float> %tmp26, <4 x float> %tmp53) { + ; (X+Y)-Y != X for fp vectors. + %tmp64 = add <4 x float> %tmp26, %tmp53 + %tmp75 = sub <4 x float> %tmp64, %tmp53 + ret <4 x float> %tmp75 +} diff --git a/llvm/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll b/llvm/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll new file mode 100644 index 00000000000..4661dfe55bb --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-05-fp-to-int-ext.ll @@ -0,0 +1,13 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep zext + +; Never merge these two conversions, even though it's possible: this is +; significantly more expensive than the two conversions on some targets +; and it causes libgcc to be compile __fixunsdfdi into a recursive +; function. + + +long %test(double %D) { + %A = fptoui double %D to uint + %B = zext uint %A to long + ret long %B +} diff --git a/llvm/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll b/llvm/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll new file mode 100644 index 00000000000..7d4e3f3f779 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-08-ICmp-Combining.ll @@ -0,0 +1,16 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep '%bothcond =' +bool %Doit_bb(int %i.0) { +bb: ; preds = %newFuncRoot + %tmp = setgt int %i.0, 0 ; <bool> [#uses=1] + %tmp.not = xor bool %tmp, true ; <bool> [#uses=1] + %tmp2 = setgt int %i.0, 8 ; <bool> [#uses=1] + %bothcond = or bool %tmp.not, %tmp2 ; <bool> [#uses=1] + br bool %bothcond, label %exitTrue, label %exitFalse + +exitTrue: ; preds = %bb + ret bool true + +exitFalse: ; preds = %bb + ret bool false + +} diff --git a/llvm/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll b/llvm/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll new file mode 100644 index 00000000000..3c2c25c31d1 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-08-Phi-ICmp-Op-Fold.ll @@ -0,0 +1,54 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis|grep 'icmp slt' +; ModuleID = 'visible.bc' +target datalayout = "e-p:32:32" +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" + %struct.point = type { int, int } + +implementation ; Functions: + +int %visible(int %direction, long %p1.0, long %p2.0, long %p3.0) { +entry: + %p1_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + %p2_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + %p3_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + "alloca point" = bitcast int 0 to int ; <int> [#uses=0] + %tmp = bitcast %struct.point* %p1_addr to { long }* ; <{ long }*> [#uses=1] + %tmp = getelementptr { long }* %tmp, uint 0, uint 0 ; <long*> [#uses=1] + store long %p1.0, long* %tmp + %tmp1 = bitcast %struct.point* %p2_addr to { long }* ; <{ long }*> [#uses=1] + %tmp2 = getelementptr { long }* %tmp1, uint 0, uint 0 ; <long*> [#uses=1] + store long %p2.0, long* %tmp2 + %tmp3 = bitcast %struct.point* %p3_addr to { long }* ; <{ long }*> [#uses=1] + %tmp4 = getelementptr { long }* %tmp3, uint 0, uint 0 ; <long*> [#uses=1] + store long %p3.0, long* %tmp4 + %tmp = seteq int %direction, 0 ; <bool> [#uses=1] + %tmp5 = bitcast %struct.point* %p1_addr to { long }* ; <{ long }*> [#uses=1] + %tmp6 = getelementptr { long }* %tmp5, uint 0, uint 0 ; <long*> [#uses=1] + %tmp = load long* %tmp6 ; <long> [#uses=1] + %tmp7 = bitcast %struct.point* %p2_addr to { long }* ; <{ long }*> [#uses=1] + %tmp8 = getelementptr { long }* %tmp7, uint 0, uint 0 ; <long*> [#uses=1] + %tmp9 = load long* %tmp8 ; <long> [#uses=1] + %tmp10 = bitcast %struct.point* %p3_addr to { long }* ; <{ long }*> [#uses=1] + %tmp11 = getelementptr { long }* %tmp10, uint 0, uint 0 ; <long*> [#uses=1] + %tmp12 = load long* %tmp11 ; <long> [#uses=1] + %tmp13 = call int %determinant( long %tmp, long %tmp9, long %tmp12 ) ; <int> [#uses=2] + br bool %tmp, label %cond_true, label %cond_false + +cond_true: ; preds = %entry + %tmp14 = setlt int %tmp13, 0 ; <bool> [#uses=1] + %tmp14 = zext bool %tmp14 to int ; <int> [#uses=1] + br label %return + +cond_false: ; preds = %entry + %tmp26 = setgt int %tmp13, 0 ; <bool> [#uses=1] + %tmp26 = zext bool %tmp26 to int ; <int> [#uses=1] + br label %return + +return: ; preds = %cond_false, %cond_true + %retval.0 = phi int [ %tmp14, %cond_true ], [ %tmp26, %cond_false ] ; <int> [#uses=1] + ret int %retval.0 +} + +declare int %determinant(long, long, long) diff --git a/llvm/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll b/llvm/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll new file mode 100644 index 00000000000..647e15df98f --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-08-Select-ICmp.ll @@ -0,0 +1,42 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep select +target datalayout = "e-p:32:32" +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" + %struct.point = type { int, int } + +implementation ; Functions: + +int %visible(int %direction, long %p1.0, long %p2.0, long %p3.0) { +entry: + %p1_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + %p2_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + %p3_addr = alloca %struct.point ; <%struct.point*> [#uses=2] + %tmp = bitcast %struct.point* %p1_addr to { long }* ; <{ long }*> [#uses=1] + %tmp = getelementptr { long }* %tmp, int 0, uint 0 ; <long*> [#uses=1] + store long %p1.0, long* %tmp + %tmp1 = bitcast %struct.point* %p2_addr to { long }* ; <{ long }*> [#uses=1] + %tmp2 = getelementptr { long }* %tmp1, int 0, uint 0 ; <long*> [#uses=1] + store long %p2.0, long* %tmp2 + %tmp3 = bitcast %struct.point* %p3_addr to { long }* ; <{ long }*> [#uses=1] + %tmp4 = getelementptr { long }* %tmp3, int 0, uint 0 ; <long*> [#uses=1] + store long %p3.0, long* %tmp4 + %tmp = seteq int %direction, 0 ; <bool> [#uses=1] + %tmp5 = bitcast %struct.point* %p1_addr to { long }* ; <{ long }*> [#uses=1] + %tmp6 = getelementptr { long }* %tmp5, int 0, uint 0 ; <long*> [#uses=1] + %tmp = load long* %tmp6 ; <long> [#uses=1] + %tmp7 = bitcast %struct.point* %p2_addr to { long }* ; <{ long }*> [#uses=1] + %tmp8 = getelementptr { long }* %tmp7, int 0, uint 0 ; <long*> [#uses=1] + %tmp9 = load long* %tmp8 ; <long> [#uses=1] + %tmp10 = bitcast %struct.point* %p3_addr to { long }* ; <{ long }*> [#uses=1] + %tmp11 = getelementptr { long }* %tmp10, int 0, uint 0 ; <long*> [#uses=1] + %tmp12 = load long* %tmp11 ; <long> [#uses=1] + %tmp13 = call int %determinant( long %tmp, long %tmp9, long %tmp12 ) ; <int> [#uses=2] + %tmp14 = setlt int %tmp13, 0 ; <bool> [#uses=1] + %tmp26 = setgt int %tmp13, 0 ; <bool> [#uses=1] + %retval.0.in = select bool %tmp, bool %tmp14, bool %tmp26 ; <bool> [#uses=1] + %retval.0 = zext bool %retval.0.in to int ; <int> [#uses=1] + ret int %retval.0 +} + +declare int %determinant(long, long, long) diff --git a/llvm/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll b/llvm/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll new file mode 100644 index 00000000000..e5ac37b950b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-10-ICmp-GEP-GEP.ll @@ -0,0 +1,165 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep -v 'icmp ult int' +; ModuleID = 'good.bc' +target datalayout = "e-p:32:32" +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" + %struct.edgeBox = type { short, short, short, short, short, short } +%qsz = external global int ; <int*> [#uses=12] +%thresh = external global int ; <int*> [#uses=2] +%mthresh = external global int ; <int*> [#uses=1] + +implementation ; Functions: + +int %qsorte(sbyte* %base, int %n, int %size) { +entry: + %tmp = setgt int %n, 1 ; <bool> [#uses=1] + br bool %tmp, label %cond_next, label %return + +cond_next: ; preds = %entry + store int %size, int* %qsz + %tmp3 = shl int %size, ubyte 2 ; <int> [#uses=1] + store int %tmp3, int* %thresh + %tmp4 = load int* %qsz ; <int> [#uses=1] + %tmp5 = mul int %tmp4, 6 ; <int> [#uses=1] + store int %tmp5, int* %mthresh + %tmp6 = load int* %qsz ; <int> [#uses=1] + %tmp8 = mul int %tmp6, %n ; <int> [#uses=1] + %tmp9 = getelementptr sbyte* %base, int %tmp8 ; <sbyte*> [#uses=3] + %tmp11 = setgt int %n, 3 ; <bool> [#uses=1] + br bool %tmp11, label %cond_true12, label %bb30 + +cond_true12: ; preds = %cond_next + %tmp156 = call int %qste( sbyte* %base, sbyte* %tmp9 ) ; <int> [#uses=0] + %tmp16 = load int* %thresh ; <int> [#uses=1] + %tmp18 = getelementptr sbyte* %base, int %tmp16 ; <sbyte*> [#uses=2] + %tmp3117 = load int* %qsz ; <int> [#uses=1] + %tmp3318 = getelementptr sbyte* %base, int %tmp3117 ; <sbyte*> [#uses=2] + %tmp3621 = setlt sbyte* %tmp3318, %tmp18 ; <bool> [#uses=1] + br bool %tmp3621, label %bb, label %bb37 + +bb: ; preds = %bb30, %cond_true12 + %hi.0.0 = phi sbyte* [ %tmp18, %cond_true12 ], [ %hi.0, %bb30 ] ; <sbyte*> [#uses=4] + %j.1.0 = phi sbyte* [ %base, %cond_true12 ], [ %j.1, %bb30 ] ; <sbyte*> [#uses=4] + %tmp33.0 = phi sbyte* [ %tmp3318, %cond_true12 ], [ %tmp33, %bb30 ] ; <sbyte*> [#uses=6] + %tmp3 = bitcast sbyte* %j.1.0 to %struct.edgeBox* ; <%struct.edgeBox*> [#uses=1] + %tmp4 = bitcast sbyte* %tmp33.0 to %struct.edgeBox* ; <%struct.edgeBox*> [#uses=1] + %tmp255 = call int %comparee( %struct.edgeBox* %tmp3, %struct.edgeBox* %tmp4 ) ; <int> [#uses=1] + %tmp26 = setgt int %tmp255, 0 ; <bool> [#uses=1] + br bool %tmp26, label %cond_true27, label %bb30 + +cond_true27: ; preds = %bb + br label %bb30 + +bb30: ; preds = %cond_true27, %bb, %cond_next + %hi.0.3 = phi sbyte* [ %hi.0.0, %cond_true27 ], [ %hi.0.0, %bb ], [ undef, %cond_next ] ; <sbyte*> [#uses=0] + %j.1.3 = phi sbyte* [ %j.1.0, %cond_true27 ], [ %j.1.0, %bb ], [ undef, %cond_next ] ; <sbyte*> [#uses=0] + %tmp33.3 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ undef, %cond_next ] ; <sbyte*> [#uses=0] + %hi.0 = phi sbyte* [ %tmp9, %cond_next ], [ %hi.0.0, %bb ], [ %hi.0.0, %cond_true27 ] ; <sbyte*> [#uses=2] + %lo.1 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %tmp33.0, %bb ], [ %base, %cond_next ] ; <sbyte*> [#uses=1] + %j.1 = phi sbyte* [ %tmp33.0, %cond_true27 ], [ %j.1.0, %bb ], [ %base, %cond_next ] ; <sbyte*> [#uses=2] + %tmp31 = load int* %qsz ; <int> [#uses=1] + %tmp33 = getelementptr sbyte* %lo.1, int %tmp31 ; <sbyte*> [#uses=2] + %tmp36 = setlt sbyte* %tmp33, %hi.0 ; <bool> [#uses=1] + br bool %tmp36, label %bb, label %bb37 + +bb37: ; preds = %bb30, %cond_true12 + %j.1.1 = phi sbyte* [ %j.1, %bb30 ], [ %base, %cond_true12 ] ; <sbyte*> [#uses=4] + %tmp40 = seteq sbyte* %j.1.1, %base ; <bool> [#uses=1] + br bool %tmp40, label %bb115, label %cond_true41 + +cond_true41: ; preds = %bb37 + %tmp43 = load int* %qsz ; <int> [#uses=1] + %tmp45 = getelementptr sbyte* %base, int %tmp43 ; <sbyte*> [#uses=2] + %tmp6030 = setlt sbyte* %base, %tmp45 ; <bool> [#uses=1] + br bool %tmp6030, label %bb46, label %bb115 + +bb46: ; preds = %bb46, %cond_true41 + %j.2.0 = phi sbyte* [ %j.1.1, %cond_true41 ], [ %tmp52, %bb46 ] ; <sbyte*> [#uses=3] + %i.2.0 = phi sbyte* [ %base, %cond_true41 ], [ %tmp56, %bb46 ] ; <sbyte*> [#uses=3] + %tmp = load sbyte* %j.2.0 ; <sbyte> [#uses=2] + %tmp49 = load sbyte* %i.2.0 ; <sbyte> [#uses=1] + store sbyte %tmp49, sbyte* %j.2.0 + %tmp52 = getelementptr sbyte* %j.2.0, int 1 ; <sbyte*> [#uses=2] + store sbyte %tmp, sbyte* %i.2.0 + %tmp56 = getelementptr sbyte* %i.2.0, int 1 ; <sbyte*> [#uses=3] + %tmp60 = setlt sbyte* %tmp56, %tmp45 ; <bool> [#uses=1] + br bool %tmp60, label %bb46, label %bb115 + +bb66: ; preds = %bb115, %bb66 + %hi.3 = phi sbyte* [ %tmp118, %bb115 ], [ %tmp70, %bb66 ] ; <sbyte*> [#uses=2] + %tmp67 = load int* %qsz ; <int> [#uses=2] + %tmp68 = sub int 0, %tmp67 ; <int> [#uses=1] + %tmp70 = getelementptr sbyte* %hi.3, int %tmp68 ; <sbyte*> [#uses=2] + %tmp = bitcast sbyte* %tmp70 to %struct.edgeBox* ; <%struct.edgeBox*> [#uses=1] + %tmp1 = bitcast sbyte* %tmp118 to %struct.edgeBox* ; <%struct.edgeBox*> [#uses=1] + %tmp732 = call int %comparee( %struct.edgeBox* %tmp, %struct.edgeBox* %tmp1 ) ; <int> [#uses=1] + %tmp74 = setgt int %tmp732, 0 ; <bool> [#uses=1] + br bool %tmp74, label %bb66, label %bb75 + +bb75: ; preds = %bb66 + %tmp76 = load int* %qsz ; <int> [#uses=1] + %tmp70.sum = sub int %tmp76, %tmp67 ; <int> [#uses=1] + %tmp78 = getelementptr sbyte* %hi.3, int %tmp70.sum ; <sbyte*> [#uses=3] + %tmp81 = seteq sbyte* %tmp78, %tmp118 ; <bool> [#uses=1] + br bool %tmp81, label %bb115, label %cond_true82 + +cond_true82: ; preds = %bb75 + %tmp83 = load int* %qsz ; <int> [#uses=1] + %tmp118.sum = add int %tmp116, %tmp83 ; <int> [#uses=1] + %tmp85 = getelementptr sbyte* %min.1, int %tmp118.sum ; <sbyte*> [#uses=1] + %tmp10937 = getelementptr sbyte* %tmp85, int -1 ; <sbyte*> [#uses=3] + %tmp11239 = setlt sbyte* %tmp10937, %tmp118 ; <bool> [#uses=1] + br bool %tmp11239, label %bb115, label %bb86 + +bb86: ; preds = %bb104, %cond_true82 + %tmp109.0 = phi sbyte* [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ] ; <sbyte*> [#uses=5] + %i.5.2 = phi sbyte* [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ] ; <sbyte*> [#uses=0] + %tmp100.2 = phi sbyte* [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ] ; <sbyte*> [#uses=0] + %tmp88 = load sbyte* %tmp109.0 ; <sbyte> [#uses=2] + %tmp9746 = load int* %qsz ; <int> [#uses=1] + %tmp9847 = sub int 0, %tmp9746 ; <int> [#uses=1] + %tmp10048 = getelementptr sbyte* %tmp109.0, int %tmp9847 ; <sbyte*> [#uses=3] + %tmp10350 = setlt sbyte* %tmp10048, %tmp78 ; <bool> [#uses=1] + br bool %tmp10350, label %bb104, label %bb91 + +bb91: ; preds = %bb91, %bb86 + %i.5.0 = phi sbyte* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ] ; <sbyte*> [#uses=1] + %tmp100.0 = phi sbyte* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ] ; <sbyte*> [#uses=4] + %tmp93 = load sbyte* %tmp100.0 ; <sbyte> [#uses=1] + store sbyte %tmp93, sbyte* %i.5.0 + %tmp97 = load int* %qsz ; <int> [#uses=1] + %tmp98 = sub int 0, %tmp97 ; <int> [#uses=1] + %tmp100 = getelementptr sbyte* %tmp100.0, int %tmp98 ; <sbyte*> [#uses=3] + %tmp103 = setlt sbyte* %tmp100, %tmp78 ; <bool> [#uses=1] + br bool %tmp103, label %bb104, label %bb91 + +bb104: ; preds = %bb91, %bb86 + %i.5.1 = phi sbyte* [ %tmp109.0, %bb86 ], [ %tmp100.0, %bb91 ] ; <sbyte*> [#uses=4] + %tmp100.1 = phi sbyte* [ %tmp10048, %bb86 ], [ %tmp100, %bb91 ] ; <sbyte*> [#uses=3] + store sbyte %tmp88, sbyte* %i.5.1 + %tmp109 = getelementptr sbyte* %tmp109.0, int -1 ; <sbyte*> [#uses=3] + %tmp112 = setlt sbyte* %tmp109, %tmp118 ; <bool> [#uses=1] + br bool %tmp112, label %bb115, label %bb86 + +bb115: ; preds = %bb104, %cond_true82, %bb75, %bb46, %cond_true41, %bb37 + %tmp109.1 = phi sbyte* [ undef, %bb37 ], [ %tmp109.1, %bb75 ], [ %tmp10937, %cond_true82 ], [ %tmp109, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ] ; <sbyte*> [#uses=1] + %i.5.3 = phi sbyte* [ undef, %bb37 ], [ %i.5.3, %bb75 ], [ %i.5.3, %cond_true82 ], [ %i.5.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ] ; <sbyte*> [#uses=3] + %tmp100.3 = phi sbyte* [ undef, %bb37 ], [ %tmp100.3, %bb75 ], [ %tmp100.3, %cond_true82 ], [ %tmp100.1, %bb104 ], [ undef, %bb46 ], [ undef, %cond_true41 ] ; <sbyte*> [#uses=3] + %min.1 = phi sbyte* [ %tmp118, %bb104 ], [ %tmp118, %bb75 ], [ %base, %bb37 ], [ %base, %bb46 ], [ %base, %cond_true41 ], [ %tmp118, %cond_true82 ] ; <sbyte*> [#uses=2] + %j.5 = phi sbyte* [ %tmp100.1, %bb104 ], [ %j.5, %bb75 ], [ %tmp52, %bb46 ], [ %j.1.1, %bb37 ], [ %j.1.1, %cond_true41 ], [ %j.5, %cond_true82 ] ; <sbyte*> [#uses=2] + %i.4 = phi sbyte* [ %i.5.1, %bb104 ], [ %i.4, %bb75 ], [ %tmp56, %bb46 ], [ undef, %bb37 ], [ %base, %cond_true41 ], [ %i.4, %cond_true82 ] ; <sbyte*> [#uses=2] + %c.4 = phi sbyte [ %tmp88, %bb104 ], [ %c.4, %bb75 ], [ %tmp, %bb46 ], [ undef, %bb37 ], [ undef, %cond_true41 ], [ %c.4, %cond_true82 ] ; <sbyte> [#uses=2] + %tmp116 = load int* %qsz ; <int> [#uses=2] + %tmp118 = getelementptr sbyte* %min.1, int %tmp116 ; <sbyte*> [#uses=9] + %tmp122 = setlt sbyte* %tmp118, %tmp9 ; <bool> [#uses=1] + br bool %tmp122, label %bb66, label %return + +return: ; preds = %bb115, %entry + ret int undef +} + +declare int %qste(sbyte*, sbyte*) + +declare int %comparee(%struct.edgeBox*, %struct.edgeBox*) diff --git a/llvm/test/Transforms/InstCombine/2006-12-15-Range-Test.ll b/llvm/test/Transforms/InstCombine/2006-12-15-Range-Test.ll new file mode 100644 index 00000000000..30ea4ee445a --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-15-Range-Test.ll @@ -0,0 +1,35 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'icmp' | wc -l | grep 1 +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'icmp ugt' | wc -l | grep 1 +; +; ModuleID = 'bugpoint-tooptimize.bc' +target datalayout = "e-p:32:32" +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" +%r = external global [17 x int] ; <[17 x int]*> [#uses=1] + +implementation ; Functions: + +bool %print_pgm_cond_true(int %tmp12.reload, int* %tmp16.out) { +newFuncRoot: + br label %cond_true + +bb27.exitStub: ; preds = %cond_true + store int %tmp16, int* %tmp16.out + ret bool true + +cond_next23.exitStub: ; preds = %cond_true + store int %tmp16, int* %tmp16.out + ret bool false + +cond_true: ; preds = %newFuncRoot + %tmp15 = getelementptr [17 x int]* %r, int 0, int %tmp12.reload ; <int*> [#uses=1] + %tmp16 = load int* %tmp15 ; <int> [#uses=4] + %tmp18 = icmp slt int %tmp16, -31 ; <bool> [#uses=1] + %tmp21 = icmp sgt int %tmp16, 31 ; <bool> [#uses=1] + %bothcond = or bool %tmp18, %tmp21 ; <bool> [#uses=1] + br bool %bothcond, label %bb27.exitStub, label %cond_next23.exitStub +} + diff --git a/llvm/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll b/llvm/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll new file mode 100644 index 00000000000..b9881e3624b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2006-12-23-Select-Cmp-Cmp.ll @@ -0,0 +1,33 @@ +; For PR1065. This causes an assertion in instcombine if a select with two cmp +; operands is encountered. +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output +; ModuleID = 'PR1065.bc' +target datalayout = "e-p:32:32" +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" + %struct.internal_state = type { int } + %struct.mng_data = type { uint, sbyte*, uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, uint, uint, sbyte, uint, uint, uint, uint, ushort, ushort, ushort, sbyte, sbyte, double, double, double, sbyte, sbyte, sbyte, sbyte, uint, uint, uint, uint, int, sbyte, int, int, sbyte*, sbyte* (uint)*, void (sbyte*, uint)*, void (sbyte*, sbyte*, uint)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*, sbyte*, uint, uint*)*, sbyte (%struct.mng_data*, sbyte*, uint, uint*)*, sbyte (%struct.mng_data*, int, sbyte, int, uint, int, int, sbyte*)*, sbyte (%struct.mng_data*, int, int, sbyte*)*, sbyte (%struct.mng_data*, uint, uint)*, sbyte (%struct.mng_data*, ubyte, sbyte*, sbyte*, sbyte*, sbyte*)*, sbyte (%struct.mng_data*)*, sbyte (%struct.mng_data*, sbyte*)*, sbyte (%struct.mng_data*, sbyte*)*, sbyte (%struct.mng_data*, uint, uint)*, sbyte (%struct.mng_data*, int, uint, sbyte*)*, sbyte (%struct.mng_data*, ubyte, ubyte, uint, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte* (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint, uint, uint, uint)*, uint (%struct.mng_data*)*, sbyte (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint)*, sbyte (%struct.mng_data*, uint, uint, uint, uint, uint, uint, uint, uint)*, sbyte (%struct.mng_data*, ubyte)*, sbyte (%struct.mng_data*, uint, sbyte*)*, sbyte (%struct.mng_data*, uint, sbyte, sbyte*)*, sbyte, int, uint, sbyte*, sbyte*, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, uint, uint, ubyte, ubyte, ubyte, ubyte, ubyte, uint, sbyte, sbyte, sbyte, uint, ubyte*, uint, ubyte*, uint, sbyte, ubyte, sbyte, uint, ubyte*, ubyte*, uint, uint, ubyte*, ubyte*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, %struct.mng_pushdata*, sbyte, sbyte, int, uint, ubyte*, sbyte, sbyte, uint, uint, uint, uint, uint, uint, sbyte, sbyte, sbyte, sbyte, int, int, sbyte*, uint, uint, uint, sbyte, sbyte, uint, uint, uint, uint, sbyte, sbyte, ubyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, uint, sbyte*, sbyte*, sbyte*, uint, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, %struct.mng_savedata*, uint, uint, uint, uint, sbyte, int, int, int, int, int, int, int, int, int, int, int, int, uint, uint, uint, uint, ubyte*, ubyte*, ubyte*, sbyte, sbyte, int, int, int, int, int, int, int, int, int, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, sbyte*, [256 x ubyte], double, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, ushort, sbyte, ubyte, sbyte, ubyte, sbyte, int, int, sbyte, int, int, int, int, ushort, ushort, ushort, ubyte, ushort, ubyte, int, int, uint, uint, ubyte, uint, uint, sbyte, int, int, int, int, ubyte, uint, uint, sbyte, int, int, int, int, uint, sbyte, uint, ubyte, ushort, ushort, ushort, short, uint, [256 x %struct.mng_palette8e], uint, [256 x ubyte], uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, sbyte*, ushort, ushort, ushort, sbyte*, ubyte, ubyte, uint, uint, uint, uint, sbyte, void ()*, void ()*, void ()*, void ()*, void ()*, void ()*, sbyte*, ubyte, ubyte, ubyte, uint, sbyte*, sbyte*, ushort, ushort, ushort, ushort, int, int, sbyte*, %struct.z_stream, int, int, int, int, int, uint, sbyte, sbyte, [256 x uint], sbyte } + %struct.mng_palette8e = type { ubyte, ubyte, ubyte } + %struct.mng_pushdata = type { sbyte*, sbyte*, uint, sbyte, ubyte*, uint } + %struct.mng_savedata = type { sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, sbyte, ushort, ushort, ushort, ubyte, ushort, ubyte, ubyte, uint, uint, sbyte, int, int, int, int, uint, [256 x %struct.mng_palette8e], uint, [256 x ubyte], uint, uint, uint, uint, uint, uint, uint, uint, uint, ubyte, uint, sbyte*, ushort, ushort, ushort } + %struct.z_stream = type { ubyte*, uint, uint, ubyte*, uint, uint, sbyte*, %struct.internal_state*, sbyte* (sbyte*, uint, uint)*, void (sbyte*, sbyte*)*, sbyte*, int, uint, uint } + +implementation ; Functions: + +void %mng_write_basi() { +entry: + %tmp = load ubyte* null ; <ubyte> [#uses=1] + %tmp = icmp ugt ubyte %tmp, 8 ; <bool> [#uses=1] + %tmp = load ushort* null ; <ushort> [#uses=2] + %tmp3 = icmp eq ushort %tmp, 255 ; <bool> [#uses=1] + %tmp7 = icmp eq ushort %tmp, -1 ; <bool> [#uses=1] + %bOpaque.0.in = select bool %tmp, bool %tmp7, bool %tmp3 ; <bool> [#uses=1] + br bool %bOpaque.0.in, label %cond_next90, label %bb95 + +cond_next90: ; preds = %entry + ret void + +bb95: ; preds = %entry + ret void +} diff --git a/llvm/test/Transforms/InstCombine/2007-01-13-ExtCompareMiscompile.ll b/llvm/test/Transforms/InstCombine/2007-01-13-ExtCompareMiscompile.ll new file mode 100644 index 00000000000..0add14bf24d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2007-01-13-ExtCompareMiscompile.ll @@ -0,0 +1,9 @@ +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep zext +; PR1107 + +define i1 %test(i8 %A, i8 %B) { + %a = zext i8 %A to i32 + %b = zext i8 %B to i32 + %c = icmp sgt i32 %a, %b + ret i1 %c +} diff --git a/llvm/test/Transforms/InstCombine/2007-01-14-FcmpSelf.ll b/llvm/test/Transforms/InstCombine/2007-01-14-FcmpSelf.ll new file mode 100644 index 00000000000..3b34a7db9dc --- /dev/null +++ b/llvm/test/Transforms/InstCombine/2007-01-14-FcmpSelf.ll @@ -0,0 +1,6 @@ +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep 'fcmp uno.*0.0' +; PR1111 +define i1 %test(double %X) { +%tmp = fcmp une double %X, %X + ret i1 %tmp +} diff --git a/llvm/test/Transforms/InstCombine/CPP_min_max.llx b/llvm/test/Transforms/InstCombine/CPP_min_max.llx new file mode 100644 index 00000000000..e64d0b91887 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/CPP_min_max.llx @@ -0,0 +1,34 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep select | not grep 'int\*' + +; This testcase corresponds to PR362, which notices that this horrible code +; is generated by the C++ front-end and LLVM optimizers, which has lots of +; loads and other stuff that are unneeded. +; +; Instcombine should propagate the load through the select instructions to +; allow elimination of the extra stuff by the mem2reg pass. + +implementation ; Functions: + +void %_Z5test1RiS_(int* %x, int* %y) { +entry: + %tmp.1.i = load int* %y ; <int> [#uses=1] + %tmp.3.i = load int* %x ; <int> [#uses=1] + %tmp.4.i = setlt int %tmp.1.i, %tmp.3.i ; <bool> [#uses=1] + %retval.i = select bool %tmp.4.i, int* %y, int* %x ; <int*> [#uses=1] + %tmp.4 = load int* %retval.i ; <int> [#uses=1] + store int %tmp.4, int* %x + ret void +} + +void %_Z5test2RiS_(int* %x, int* %y) { +entry: + %tmp.0 = alloca int ; <int*> [#uses=2] + %tmp.2 = load int* %x ; <int> [#uses=2] + store int %tmp.2, int* %tmp.0 + %tmp.3.i = load int* %y ; <int> [#uses=1] + %tmp.4.i = setlt int %tmp.2, %tmp.3.i ; <bool> [#uses=1] + %retval.i = select bool %tmp.4.i, int* %y, int* %tmp.0 ; <int*> [#uses=1] + %tmp.6 = load int* %retval.i ; <int> [#uses=1] + store int %tmp.6, int* %y + ret void +} diff --git a/llvm/test/Transforms/InstCombine/GEPIdxCanon.ll b/llvm/test/Transforms/InstCombine/GEPIdxCanon.ll new file mode 100644 index 00000000000..afaabc3e2f0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/GEPIdxCanon.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -gcse -instcombine | llvm-dis | not grep getelementptr + +bool %test(int* %A) { + %B = getelementptr int* %A, int 1 + %C = getelementptr int* %A, uint 1 + %V = seteq int* %B, %C + ret bool %V +} diff --git a/llvm/test/Transforms/InstCombine/IntPtrCast.ll b/llvm/test/Transforms/InstCombine/IntPtrCast.ll new file mode 100644 index 00000000000..9f509b6fbc0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/IntPtrCast.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast +target pointersize = 32 + +int *%test(int *%P) { + %V = cast int* %P to int + %P2 = cast int %V to int* + ret int* %P2 +} diff --git a/llvm/test/Transforms/InstCombine/JavaCompare.ll b/llvm/test/Transforms/InstCombine/JavaCompare.ll new file mode 100644 index 00000000000..11f706e5662 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/JavaCompare.ll @@ -0,0 +1,14 @@ +; This is the sequence of stuff that the Java front-end expands for a single +; <= comparison. Check to make sure we turn it into a <= (only) + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v 'icmp sle'| not grep '#uses' + +bool %le(int %A, int %B) { + %c1 = setgt int %A, %B; + %tmp = select bool %c1, int 1, int 0; + %c2 = setlt int %A, %B; + %result = select bool %c2, int -1, int %tmp; + %c3 = setle int %result, 0; + ret bool %c3; +} + diff --git a/llvm/test/Transforms/InstCombine/README.txt b/llvm/test/Transforms/InstCombine/README.txt new file mode 100644 index 00000000000..de043c77489 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/README.txt @@ -0,0 +1,4 @@ +This directory contains test cases for the instcombine transformation. The +dated tests are actual bug tests, whereas the named tests are used to test +for features that the this pass should be capable of performing. + diff --git a/llvm/test/Transforms/InstCombine/add.ll b/llvm/test/Transforms/InstCombine/add.ll new file mode 100644 index 00000000000..ec3aea3c877 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/add.ll @@ -0,0 +1,249 @@ +; This test makes sure that add instructions are properly eliminated. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v OK | not grep add + +implementation + +int %test1(int %A) { + %B = add int %A, 0 + ret int %B +} + +int %test2(int %A) { + %B = add int %A, 5 + %C = add int %B, -5 + ret int %C +} + +int %test3(int %A) { + %B = add int %A, 5 + %C = sub int %B, 5 ;; This should get converted to an add + ret int %C +} + +int %test4(int %A, int %B) { + %C = sub int 0, %A + %D = add int %B, %C ; D = B + -A = B - A + ret int %D +} + +int %test5(int %A, int %B) { + %C = sub int 0, %A + %D = add int %C, %B ; D = -A + B = B - A + ret int %D +} + +int %test6(int %A) { + %B = mul int 7, %A + %C = add int %B, %A ; C = 7*A+A == 8*A == A << 3 + ret int %C +} + +int %test7(int %A) { + %B = mul int 7, %A + %C = add int %A, %B ; C = A+7*A == 8*A == A << 3 + ret int %C +} + +int %test8(int %A, int %B) { ; (A & C1)+(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0 + %A1 = and int %A, 7 + %B1 = and int %B, 128 + %C = add int %A1, %B1 + ret int %C +} + +int %test9(int %A) { + %B = shl int %A, ubyte 4 + %C = add int %B, %B ; === shl int %A, 5 + ret int %C +} + +bool %test10(ubyte %A, ubyte %b) { + %B = add ubyte %A, %b + %c = setne ubyte %B, 0 ; === A != -b + ret bool %c +} + +bool %test11(ubyte %A) { + %B = add ubyte %A, 255 + %c = setne ubyte %B, 0 ; === A != 1 + ret bool %c +} + +int %test12(int %A, int %B) { + %C_OK = add int %B, %A ; Should be transformed into shl A, 1 + br label %X +X: + %D = add int %C_OK, %A + ret int %D +} + +int %test13(int %A, int %B, int %C) { + %D_OK = add int %A, %B + %E_OK = add int %D_OK, %C + %F = add int %E_OK, %A ;; shl A, 1 + ret int %F +} + +uint %test14(uint %offset, uint %difference) { + %tmp.2 = and uint %difference, 3 + %tmp.3_OK = add uint %tmp.2, %offset + %tmp.5.mask = and uint %difference, 4294967292 + %tmp.8 = add uint %tmp.3_OK, %tmp.5.mask ; == add %offset, %difference + ret uint %tmp.8 +} + +ubyte %test15(ubyte %A) { + %B = add ubyte %A, 192 ; Does not effect result + %C = and ubyte %B, 16 ; Only one bit set + ret ubyte %C +} + +ubyte %test16(ubyte %A) { + %B = add ubyte %A, 16 ; Turn this into a XOR + %C = and ubyte %B, 16 ; Only one bit set + ret ubyte %C +} + +int %test17(int %A) { + %B = xor int %A, -1 + %C = add int %B, 1 ; == sub int 0, %A + ret int %C +} + +ubyte %test18(ubyte %A) { + %B = xor ubyte %A, 255 + %C = add ubyte %B, 17 ; == sub ubyte 16, %A + ret ubyte %C +} + +int %test19(bool %C) { + %A = select bool %C, int 1000, int 10 + %V = add int %A, 123 + ret int %V +} + +int %test20(int %x) { + %tmp.2 = xor int %x, -2147483648 + ;; Add of sign bit -> xor of sign bit. + %tmp.4 = add int %tmp.2, -2147483648 + ret int %tmp.4 +} + +bool %test21(uint %x) { + %t = add uint %x, 4 + %y = seteq uint %t, 123 + ret bool %y +} + +int %test22(uint %V) { + %V2 = add uint %V, 10 + switch uint %V2, label %Default [ + uint 20, label %Lab1 + uint 30, label %Lab2 + ] +Default: + ret int 123 +Lab1: + ret int 12312 +Lab2: + ret int 1231231 +} + +int %test23(bool %C, int %a) { +entry: + br bool %C, label %endif, label %else + +else: + br label %endif + +endif: + %b.0 = phi int [ 0, %entry ], [ 1, %else ] + %tmp.4 = add int %b.0, 1 + ret int %tmp.4 +} + +int %test24(int %A) { + %B = add int %A, 1 + %C = shl int %B, ubyte 1 + %D = sub int %C, 2 + ret int %D ;; A << 1 +} + +long %test25(long %Y) { + %tmp.4 = shl long %Y, ubyte 2 + %tmp.12 = shl long %Y, ubyte 2 + %tmp.8 = add long %tmp.4, %tmp.12 ;; Y << 3 + ret long %tmp.8 +} + +int %test26(int %A, int %B) { + %C = add int %A, %B + %D = sub int %C, %B + ret int %D +} + +int %test27(bool %C, int %X, int %Y) { + %A = add int %X, %Y + %B = add int %Y, 123 + %C = select bool %C, int %A, int %B ;; Fold add through select. + %D = sub int %C, %Y + ret int %D +} + +int %test28(int %X) { + %Y = add int %X, 1234 + %Z = sub int 42, %Y + ret int %Z +} + +uint %test29(uint %X, uint %x) { + %tmp.2 = sub uint %X, %x + %tmp.2.mask = and uint %tmp.2, 63 ; <uint> [#uses=1] + %tmp.6 = add uint %tmp.2.mask, %x ; <uint> [#uses=1] + %tmp.7 = and uint %tmp.6, 63 ; <uint> [#uses=1] + %tmp.9 = and uint %tmp.2, 4294967232 ; <uint> [#uses=1] + %tmp.10 = or uint %tmp.7, %tmp.9 ; <uint> [#uses=1] + ret uint %tmp.10 +} + +long %test30(long %x) { + %tmp.2 = xor long %x, -9223372036854775808 + ;; Add of sign bit -> xor of sign bit. + %tmp.4 = add long %tmp.2, -9223372036854775808 + ret long %tmp.4 +} + +int %test31(int %A) { + %B = add int %A, 4 + %C = mul int %B, 5 + %D = sub int %C, 20 + ret int %D +} + +int %test32(int %A) { + %B = add int %A, 4 + %C = shl int %B, ubyte 2 + %D = sub int %C, 16 + ret int %D +} + +ubyte %test33(ubyte %A) { ;; OR A, 1 + %B = and ubyte %A, 254 + %C = add ubyte %B, 1 + ret ubyte %C +} + +ubyte %test34(ubyte %A) { + %B = add ubyte %A, 64 ;; dead + %C = and ubyte %B, 12 + ret ubyte %C +} + +i32 %test34(i32 %a) { ;; -> -1 + %tmpnot = xor i32 %a, -1 + %tmp2 = add i32 %tmpnot, %a + ret i32 %tmp2 +} + diff --git a/llvm/test/Transforms/InstCombine/alloca.ll b/llvm/test/Transforms/InstCombine/alloca.ll new file mode 100644 index 00000000000..8ce7b65b0c0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/alloca.ll @@ -0,0 +1,27 @@ +; Zero byte allocas should be deleted. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep alloca + +declare void %use(...) +void %test() { + %X = alloca [0 x int] + call void(...)* %use([0 x int] *%X) + %Y = alloca int, uint 0 + call void(...)* %use(int* %Y) + %Z = alloca {} + call void(...)* %use({}* %Z) + ret void +} + +void %test2() { + %A = alloca int ;; dead. + store int 123, int* %A + ret void +} + +void %test3() { + %A = alloca {int} ;; dead. + %B = getelementptr {int}* %A, int 0, uint 0 + store int 123, int* %B + ret void +} diff --git a/llvm/test/Transforms/InstCombine/and-compare.ll b/llvm/test/Transforms/InstCombine/and-compare.ll new file mode 100644 index 00000000000..864b8c25e21 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/and-compare.ll @@ -0,0 +1,10 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep and | wc -l | grep 1 + +; Should be optimized to one and. +bool %test1(uint %a, uint %b) { + %tmp1 = and uint %a, 65280 + %tmp3 = and uint %b, 65280 + %tmp = setne uint %tmp1, %tmp3 + ret bool %tmp +} + diff --git a/llvm/test/Transforms/InstCombine/and-or-and.ll b/llvm/test/Transforms/InstCombine/and-or-and.ll new file mode 100644 index 00000000000..1c8465c7302 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/and-or-and.ll @@ -0,0 +1,54 @@ +; If we have an 'and' of the result of an 'or', and one of the 'or' operands +; cannot have contributed any of the resultant bits, delete the or. This +; occurs for very common C/C++ code like this: +; +; struct foo { int A : 16; int B : 16; }; +; void test(struct foo *F, int X, int Y) { +; F->A = X; F->B = Y; +; } +; +; Which corresponds to test1. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'or ' + +int %test1(int %X, int %Y) { + %A = and int %X, 7 + %B = and int %Y, 8 + %C = or int %A, %B + %D = and int %C, 7 ;; This cannot include any bits from %Y! + ret int %D +} + +int %test2(int %X, ubyte %Y) { + %B = cast ubyte %Y to int + %C = or int %X, %B + %D = and int %C, 65536 ;; This cannot include any bits from %Y! + ret int %D +} + +int %test3(int %X, int %Y) { + %B = shl int %Y, ubyte 1 + %C = or int %X, %B + %D = and int %C, 1 ;; This cannot include any bits from %Y! + ret int %D +} + +uint %test4(uint %X, uint %Y) { + %B = shr uint %Y, ubyte 31 + %C = or uint %X, %B + %D = and uint %C, 2 ;; This cannot include any bits from %Y! + ret uint %D +} + +int %or_test1(int %X, int %Y) { + %A = and int %X, 1 + %B = or int %A, 1 ;; This cannot include any bits from X! + ret int %B +} + +ubyte %or_test2(ubyte %X, ubyte %Y) { + %A = shl ubyte %X, ubyte 7 + %B = or ubyte %A, 128 ;; This cannot include any bits from X! + ret ubyte %B +} + diff --git a/llvm/test/Transforms/InstCombine/and.ll b/llvm/test/Transforms/InstCombine/and.ll new file mode 100644 index 00000000000..dc30c564d02 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/and.ll @@ -0,0 +1,228 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep and + +implementation + +int %test1(int %A) { + %B = and int %A, 0 ; zero result + ret int %B +} + +int %test2(int %A) { + %B = and int %A, -1 ; noop + ret int %B +} + +bool %test3(bool %A) { + %B = and bool %A, false ; always = false + ret bool %B +} + +bool %test4(bool %A) { + %B = and bool %A, true ; noop + ret bool %B +} + +int %test5(int %A) { + %B = and int %A, %A + ret int %B +} + +bool %test6(bool %A) { + %B = and bool %A, %A + ret bool %B +} + +int %test7(int %A) { ; A & ~A == 0 + %NotA = xor int %A, -1 + %B = and int %A, %NotA + ret int %B +} + +ubyte %test8(ubyte %A) { ; AND associates + %B = and ubyte %A, 3 + %C = and ubyte %B, 4 + ret ubyte %C +} + +bool %test9(int %A) { + %B = and int %A, -2147483648 ; Test of sign bit, convert to setle %A, 0 + %C = setne int %B, 0 + ret bool %C +} + +bool %test9(uint %A) { + %B = and uint %A, 2147483648 ; Test of sign bit, convert to setle %A, 0 + %C = setne uint %B, 0 + ret bool %C +} + +uint %test10(uint %A) { + %B = and uint %A, 12 + %C = xor uint %B, 15 + %D = and uint %C, 1 ; (X ^ C1) & C2 --> (X & C2) ^ (C1&C2) + ret uint %D +} + +uint %test11(uint %A, uint* %P) { + %B = or uint %A, 3 + %C = xor uint %B, 12 + store uint %C, uint* %P ; additional use of C + %D = and uint %C, 3 ; %C = and uint %B, 3 --> 3 + ret uint %D +} + +bool %test12(uint %A, uint %B) { + %C1 = setlt uint %A, %B + %C2 = setle uint %A, %B + %D = and bool %C1, %C2 ; (A < B) & (A <= B) === (A < B) + ret bool %D +} + +bool %test13(uint %A, uint %B) { + %C1 = setlt uint %A, %B + %C2 = setgt uint %A, %B + %D = and bool %C1, %C2 ; (A < B) & (A > B) === false + ret bool %D +} + +bool %test14(ubyte %A) { + %B = and ubyte %A, 128 + %C = setne ubyte %B, 0 + ret bool %C +} + +ubyte %test15(ubyte %A) { + %B = shr ubyte %A, ubyte 7 + %C = and ubyte %B, 2 ; Always equals zero + ret ubyte %C +} + +ubyte %test16(ubyte %A) { + %B = shl ubyte %A, ubyte 2 + %C = and ubyte %B, 3 + ret ubyte %C +} + +sbyte %test17(sbyte %X, sbyte %Y) { ;; ~(~X & Y) --> (X | ~Y) + %B = xor sbyte %X, -1 + %C = and sbyte %B, %Y + %D = xor sbyte %C, -1 + ret sbyte %D +} + +bool %test18(int %A) { + %B = and int %A, -128 + %C = setne int %B, 0 ;; C >= 128 + ret bool %C +} + +bool %test18a(ubyte %A) { + %B = and ubyte %A, 254 + %C = seteq ubyte %B, 0 + ret bool %C +} + +int %test19(int %A) { + %B = shl int %A, ubyte 3 + %C = and int %B, -2 ;; Clearing a zero bit + ret int %C +} + +ubyte %test20(ubyte %A) { + %C = shr ubyte %A, ubyte 7 + %D = and ubyte %C, 1 ;; Unneeded + ret ubyte %D +} + +bool %test22(int %A) { + %B = seteq int %A, 1 + %C = setge int %A, 3 + %D = and bool %B, %C ;; False + ret bool %D +} + +bool %test23(int %A) { + %B = setgt int %A, 1 + %C = setle int %A, 2 + %D = and bool %B, %C ;; A == 2 + ret bool %D +} + +bool %test24(int %A) { + %B = setgt int %A, 1 + %C = setne int %A, 2 + %D = and bool %B, %C ;; A > 2 + ret bool %D +} + +bool %test25(int %A) { + %B = setge int %A, 50 + %C = setlt int %A, 100 + %D = and bool %B, %C ;; (A-50) <u 50 + ret bool %D +} + +bool %test26(int %A) { + %B = setne int %A, 50 + %C = setne int %A, 51 + %D = and bool %B, %C ;; (A-50) > 1 + ret bool %D +} + +ubyte %test27(ubyte %A) { + %B = and ubyte %A, 4 + %C = sub ubyte %B, 16 + %D = and ubyte %C, 240 ;; 0xF0 + %E = add ubyte %D, 16 + ret ubyte %E +} + +int %test28(int %X) { ;; This is juse a zero extending shr. + %Y = shr int %X, ubyte 24 ;; Sign extend + %Z = and int %Y, 255 ;; Mask out sign bits + ret int %Z +} + +int %test29(ubyte %X) { + %Y = cast ubyte %X to int + %Z = and int %Y, 255 ;; Zero extend makes this unneeded. + ret int %Z +} + +int %test30(bool %X) { + %Y = cast bool %X to int + %Z = and int %Y, 1 + ret int %Z +} + +uint %test31(bool %X) { + %Y = cast bool %X to uint + %Z = shl uint %Y, ubyte 4 + %A = and uint %Z, 16 + ret uint %A +} + +uint %test32(uint %In) { + %Y = and uint %In, 16 + %Z = shr uint %Y, ubyte 2 + %A = and uint %Z, 1 + ret uint %A +} + +uint %test33(uint %b) { ;; Code corresponding to one-bit bitfield ^1. + %tmp.4.mask = and uint %b, 1 + %tmp.10 = xor uint %tmp.4.mask, 1 + %tmp.12 = and uint %b, 4294967294 + %tmp.13 = or uint %tmp.12, %tmp.10 + ret uint %tmp.13 +} + +int %test34(int %A, int %B) { + %tmp.2 = or int %B, %A + %tmp.4 = and int %tmp.2, %B + ret int %tmp.4 +} + diff --git a/llvm/test/Transforms/InstCombine/binop-cast.ll b/llvm/test/Transforms/InstCombine/binop-cast.ll new file mode 100644 index 00000000000..7ca01511597 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/binop-cast.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast + +uint %testAdd(int %X, int %Y) { + %tmp = add int %X, %Y + %tmp.l = sext int %tmp to uint + ret uint %tmp.l +} diff --git a/llvm/test/Transforms/InstCombine/bit-tracking.ll b/llvm/test/Transforms/InstCombine/bit-tracking.ll new file mode 100644 index 00000000000..f6654738d7f --- /dev/null +++ b/llvm/test/Transforms/InstCombine/bit-tracking.ll @@ -0,0 +1,26 @@ +; This file contains various testcases that require tracking whether bits are +; set or cleared by various instructions. +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -instcombine | llvm-dis | not grep %ELIM + +; Reduce down to a single XOR +int %test3(int %B) { + %ELIMinc = and int %B, 1 + %tmp.5 = xor int %ELIMinc, 1 + %ELIM7 = and int %B, -2 + %tmp.8 = or int %tmp.5, %ELIM7 + ret int %tmp.8 +} + +; Finally, a bigger case where we chain things together. This corresponds to +; incrementing a single-bit bitfield, which should become just an xor. +int %test4(int %B) { + %ELIM3 = shl int %B, ubyte 31 + %ELIM4 = shr int %ELIM3, ubyte 31 + %inc = add int %ELIM4, 1 + %ELIM5 = and int %inc, 1 + %ELIM7 = and int %B, -2 + %tmp.8 = or int %ELIM5, %ELIM7 + ret int %tmp.8 +} + diff --git a/llvm/test/Transforms/InstCombine/bittest.ll b/llvm/test/Transforms/InstCombine/bittest.ll new file mode 100644 index 00000000000..7fb5fdee577 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/bittest.ll @@ -0,0 +1,29 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -simplifycfg -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -simplifycfg | llvm-dis | not grep 'call void %abort' + +%b_rec.0 = external global int + +void %_Z12h000007_testv(uint *%P) { +entry: + %tmp.2 = load int* %b_rec.0 ; <int> [#uses=1] + %tmp.9 = or int %tmp.2, -989855744 ; <int> [#uses=2] + %tmp.16 = and int %tmp.9, -805306369 ; <int> [#uses=2] + %tmp.17 = and int %tmp.9, -973078529 ; <int> [#uses=1] + store int %tmp.17, int* %b_rec.0 + %tmp.17.shrunk = cast int %tmp.16 to uint ; <uint> [#uses=1] + %tmp.22 = and uint %tmp.17.shrunk, 3221225472 ; <uint> [#uses=1] + %tmp.23 = seteq uint %tmp.22, 3221225472 ; <bool> [#uses=1] + br bool %tmp.23, label %endif.0, label %then.0 + +then.0: ; preds = %entry + tail call void %abort( ) + unreachable + +endif.0: ; preds = %entry + %tmp.17.shrunk2 = cast int %tmp.16 to uint ; <uint> [#uses=1] + %tmp.27.mask = and uint %tmp.17.shrunk2, 100663295 ; <uint> [#uses=1] + store uint %tmp.27.mask, uint* %P + ret void +} + +declare void %abort() diff --git a/llvm/test/Transforms/InstCombine/bswap-fold.ll b/llvm/test/Transforms/InstCombine/bswap-fold.ll new file mode 100644 index 00000000000..0ee486ad1aa --- /dev/null +++ b/llvm/test/Transforms/InstCombine/bswap-fold.ll @@ -0,0 +1,26 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep ret | wc -l | grep 3 && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'call.*bswap' + +bool %test1(ushort %tmp2) { + %tmp10 = call ushort %llvm.bswap.i16( ushort %tmp2 ) + %tmp = seteq ushort %tmp10, 1 + ret bool %tmp +} + +bool %test2(uint %tmp) { + %tmp34 = tail call uint %llvm.bswap.i32( uint %tmp ) + %tmp = seteq uint %tmp34, 1 + ret bool %tmp +} + +declare uint %llvm.bswap.i32(uint) + +bool %test3(ulong %tmp) { + %tmp34 = tail call ulong %llvm.bswap.i64( ulong %tmp ) + %tmp = seteq ulong %tmp34, 1 + ret bool %tmp +} + +declare ulong %llvm.bswap.i64(ulong) + +declare ushort %llvm.bswap.i16(ushort) diff --git a/llvm/test/Transforms/InstCombine/bswap.ll b/llvm/test/Transforms/InstCombine/bswap.ll new file mode 100644 index 00000000000..5eed8b37227 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/bswap.ll @@ -0,0 +1,61 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'call.*llvm.bswap' | wc -l | grep 5 + +uint %test1(uint %i) { + %tmp1 = shr uint %i, ubyte 24 ; <uint> [#uses=1] + %tmp3 = shr uint %i, ubyte 8 ; <uint> [#uses=1] + %tmp4 = and uint %tmp3, 65280 ; <uint> [#uses=1] + %tmp5 = or uint %tmp1, %tmp4 ; <uint> [#uses=1] + %tmp7 = shl uint %i, ubyte 8 ; <uint> [#uses=1] + %tmp8 = and uint %tmp7, 16711680 ; <uint> [#uses=1] + %tmp9 = or uint %tmp5, %tmp8 ; <uint> [#uses=1] + %tmp11 = shl uint %i, ubyte 24 ; <uint> [#uses=1] + %tmp12 = or uint %tmp9, %tmp11 ; <uint> [#uses=1] + ret uint %tmp12 +} + +uint %test2(uint %arg) { + %tmp2 = shl uint %arg, ubyte 24 ; <uint> [#uses=1] + %tmp4 = shl uint %arg, ubyte 8 ; <uint> [#uses=1] + %tmp5 = and uint %tmp4, 16711680 ; <uint> [#uses=1] + %tmp6 = or uint %tmp2, %tmp5 ; <uint> [#uses=1] + %tmp8 = shr uint %arg, ubyte 8 ; <uint> [#uses=1] + %tmp9 = and uint %tmp8, 65280 ; <uint> [#uses=1] + %tmp10 = or uint %tmp6, %tmp9 ; <uint> [#uses=1] + %tmp12 = shr uint %arg, ubyte 24 ; <uint> [#uses=1] + %tmp14 = or uint %tmp10, %tmp12 ; <uint> [#uses=1] + ret uint %tmp14 +} + +ushort %test3(ushort %s) { + %tmp2 = shr ushort %s, ubyte 8 + %tmp4 = shl ushort %s, ubyte 8 + %tmp5 = or ushort %tmp2, %tmp4 + ret ushort %tmp5 +} + +ushort %test4(ushort %s) { + %tmp2 = shr ushort %s, ubyte 8 + %tmp4 = shl ushort %s, ubyte 8 + %tmp5 = or ushort %tmp4, %tmp2 + ret ushort %tmp5 +} + +; unsigned short test5(unsigned short a) { +; return ((a & 0xff00) >> 8 | (a & 0x00ff) << 8); +;} +ushort %test5(ushort %a) { + %tmp = zext ushort %a to int + %tmp1 = and int %tmp, 65280 + %tmp2 = ashr int %tmp1, ubyte 8 + %tmp2 = trunc int %tmp2 to short + %tmp3 = zext ushort %a to int + %tmp4 = and int %tmp3, 255 + %tmp5 = shl int %tmp4, ubyte 8 + %tmp5 = trunc int %tmp5 to short + %tmp = or short %tmp2, %tmp5 + %tmp6 = bitcast short %tmp to ushort + %tmp6 = zext ushort %tmp6 to int + %retval = trunc int %tmp6 to ushort + ret ushort %retval +} + diff --git a/llvm/test/Transforms/InstCombine/call-cast-target.ll b/llvm/test/Transforms/InstCombine/call-cast-target.ll new file mode 100644 index 00000000000..4a3cb2af228 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/call-cast-target.ll @@ -0,0 +1,15 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep call | not grep bitcast + +target endian = little +target pointersize = 32 +target triple = "i686-pc-linux-gnu" + +implementation ; Functions: + +int %main() { +entry: + %tmp = call int cast (sbyte* (int*)* %ctime to int (int*)*)( int* null ) + ret int %tmp +} + +declare sbyte* %ctime(int*) diff --git a/llvm/test/Transforms/InstCombine/call-intrinsics.ll b/llvm/test/Transforms/InstCombine/call-intrinsics.ll new file mode 100644 index 00000000000..e8549981e1d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/call-intrinsics.ll @@ -0,0 +1,17 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis + +declare void %llvm.memmove.i32(sbyte*, sbyte*, uint, uint) +declare void %llvm.memcpy.i32(sbyte*, sbyte*, uint, uint) +declare void %llvm.memset.i32(sbyte*, ubyte, uint, uint) + +%X = global sbyte 0 +%Y = global sbyte 12 + +void %zero_byte_test() { + ; These process zero bytes, so they are a noop. + call void %llvm.memmove.i32(sbyte* %X, sbyte* %Y, uint 0, uint 100) + call void %llvm.memcpy.i32(sbyte* %X, sbyte* %Y, uint 0, uint 100) + call void %llvm.memset.i32(sbyte* %X, ubyte 123, uint 0, uint 100) + ret void +} + diff --git a/llvm/test/Transforms/InstCombine/call.ll b/llvm/test/Transforms/InstCombine/call.ll new file mode 100644 index 00000000000..aa9495e0c27 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/call.ll @@ -0,0 +1,56 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep call | notcast + +implementation + +; Simple case, argument translatable without changing the value +declare void %test1a(sbyte *%A) +void %test1(int *%A) { + call void(int*)* cast (void(sbyte*)* %test1a to void(int*)*)(int* %A) + ret void +} + +; More complex case, translate argument because of resolution. This is safe +; because we have the body of the function +void %test2a(sbyte %A) { ret void } +int %test2(int %A) { + call void(int)* cast (void(sbyte)* %test2a to void(int)*)(int %A) + ret int %A +} + +; Resolving this should insert a cast from sbyte to int, following the C +; promotion rules. +declare void %test3a(sbyte %A, ...) +void %test3(sbyte %A, sbyte %B) { + call void(sbyte, sbyte)* cast (void(sbyte,...)* %test3a to void(sbyte,sbyte)*)(sbyte %A, sbyte %B) + ret void +} + +; test conversion of return value... +sbyte %test4a() { ret sbyte 0 } +int %test4() { + %X = call int()* cast (sbyte()* %test4a to int()*)() + ret int %X +} + +; test conversion of return value... no value conversion occurs so we can do +; this with just a prototype... +declare uint %test5a() +int %test5() { + %X = call int()* cast (uint()* %test5a to int()*)() + ret int %X +} + +; test addition of new arguments... +declare int %test6a(int %X) +int %test6() { + %X = call int()* cast (int(int)* %test6a to int()*)() + ret int %X +} + +; test removal of arguments, only can happen with a function body +void %test7a() { ret void } +void %test7() { + call void(int)* cast (void()* %test7a to void(int)*)(int 5) + ret void +} + diff --git a/llvm/test/Transforms/InstCombine/canonicalize_branch.ll b/llvm/test/Transforms/InstCombine/canonicalize_branch.ll new file mode 100644 index 00000000000..1434c7bee08 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/canonicalize_branch.ll @@ -0,0 +1,27 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'setne\|setle\|setge' + +int %test1(uint %X, uint %Y) { + %C = setne uint %X, %Y + br bool %C, label %T, label %F +T: + ret int 12 +F: + ret int 123 +} + +int %test2(uint %X, uint %Y) { + %C = setle uint %X, %Y + br bool %C, label %T, label %F +T: + ret int 12 +F: + ret int 123 +} +int %test3(uint %X, uint %Y) { + %C = setge uint %X, %Y + br bool %C, label %T, label %F +T: + ret int 12 +F: + ret int 123 +} diff --git a/llvm/test/Transforms/InstCombine/cast-and-cast.ll b/llvm/test/Transforms/InstCombine/cast-and-cast.ll new file mode 100644 index 00000000000..b141974bece --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-and-cast.ll @@ -0,0 +1,15 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep bitcast + +bool %test1(uint %val) { + %t1 = bitcast uint %val to int + %t2 = and int %t1, 1 + %t3 = trunc int %t2 to bool + ret bool %t3 +} + +short %test1(uint %val) { + %t1 = bitcast uint %val to int + %t2 = and int %t1, 1 + %t3 = trunc int %t2 to short + ret short %t3 +} diff --git a/llvm/test/Transforms/InstCombine/cast-cast-to-and.ll b/llvm/test/Transforms/InstCombine/cast-cast-to-and.ll new file mode 100644 index 00000000000..8789b98b44b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-cast-to-and.ll @@ -0,0 +1,8 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep ubyte + +int %test1(uint %X) { + %Y = cast uint %X to ubyte ;; Turn into an AND + %Z = cast ubyte %Y to int + ret int %Z +} + diff --git a/llvm/test/Transforms/InstCombine/cast-load-gep.ll b/llvm/test/Transforms/InstCombine/cast-load-gep.ll new file mode 100644 index 00000000000..0a369bce039 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-load-gep.ll @@ -0,0 +1,22 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -globaldce | llvm-dis | not grep Array + +; Pulling the cast out of the load allows us to eliminate the load, and then +; the whole array. + +%unop = type {int } +%op = type {float} + +%Array = internal constant [1 x %op* (%op*)*] [ %op* (%op*)* %foo ] + +implementation + +%op* %foo(%op* %X) { + ret %op* %X +} + +%unop* %caller(%op* %O) { + %tmp = load %unop* (%op*)** cast ([1 x %op* (%op*)*]* %Array to %unop* (%op*)**) + %tmp.2 = call %unop* (%op*)* %tmp(%op* %O) + ret %unop* %tmp.2 +} + diff --git a/llvm/test/Transforms/InstCombine/cast-malloc.ll b/llvm/test/Transforms/InstCombine/cast-malloc.ll new file mode 100644 index 00000000000..2458bf3ea44 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-malloc.ll @@ -0,0 +1,8 @@ +; test that casted mallocs get converted to malloc of the right type +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep bitcast + +int* %test(uint %size) { + %X = malloc long, uint %size + %ret = bitcast long* %X to int* + ret int* %ret +} diff --git a/llvm/test/Transforms/InstCombine/cast-propagate.ll b/llvm/test/Transforms/InstCombine/cast-propagate.ll new file mode 100644 index 00000000000..d4f07a4d842 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-propagate.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -mem2reg | llvm-dis | not grep load + +int %test1(uint* %P) { + %A = alloca uint + store uint 123, uint* %A + %Q = cast uint* %A to int* ; Cast the result of the load not the source + %V = load int* %Q + ret int %V +} diff --git a/llvm/test/Transforms/InstCombine/cast-set.ll b/llvm/test/Transforms/InstCombine/cast-set.ll new file mode 100644 index 00000000000..801aa1bfc50 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast-set.ll @@ -0,0 +1,49 @@ +; This tests for various complex cast elimination cases instcombine should +; handle. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast + +bool %test1(int %X) { + %A = cast int %X to uint + %c = setne uint %A, 12 ; Convert to setne int %X, 12 + ret bool %c +} + +bool %test2(int %X, int %Y) { + %A = cast int %X to uint + %B = cast int %Y to uint + %c = setne uint %A, %B ; Convert to setne int %X, %Y + ret bool %c +} + +int %test4(int %A) { + %B = cast int %A to uint + %C = shl uint %B, ubyte 2 + %D = cast uint %C to int + ret int %D +} + +short %test5(short %A) { + %B = cast short %A to uint + %C = and uint %B, 15 + %D = cast uint %C to short + ret short %D +} + +bool %test6(bool %A) { + %B = cast bool %A to int + %C = setne int %B, 0 + ret bool %C +} + +bool %test6a(bool %A) { + %B = cast bool %A to int + %C = setne int %B, -1 ; Always true! + ret bool %C +} + +bool %test7(sbyte* %A) { + %B = cast sbyte* %A to int* + %C = seteq int* %B, null + ret bool %C +} diff --git a/llvm/test/Transforms/InstCombine/cast.ll b/llvm/test/Transforms/InstCombine/cast.ll new file mode 100644 index 00000000000..6cad43bd7dc --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast.ll @@ -0,0 +1,229 @@ +; Tests to make sure elimination of casts is working correctly +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep '%c' | notcast + +%inbuf = external global [32832 x ubyte] + +implementation + +int %test1(int %A) { + %c1 = cast int %A to uint + %c2 = cast uint %c1 to int + ret int %c2 +} + +ulong %test2(ubyte %A) { + %c1 = cast ubyte %A to ushort + %c2 = cast ushort %c1 to uint + %Ret = cast uint %c2 to ulong + ret ulong %Ret +} + +ulong %test3(ulong %A) { ; This function should just use bitwise AND + %c1 = cast ulong %A to ubyte + %c2 = cast ubyte %c1 to ulong + ret ulong %c2 +} + +uint %test4(int %A, int %B) { + %COND = setlt int %A, %B + %c = cast bool %COND to ubyte ; Booleans are unsigned integrals + %result = cast ubyte %c to uint ; for the cast elim purpose + ret uint %result +} + +int %test5(bool %B) { + %c = cast bool %B to ubyte ; This cast should get folded into + %result = cast ubyte %c to int ; this cast + ret int %result +} + +int %test6(ulong %A) { + %c1 = cast ulong %A to uint + %res = cast uint %c1 to int + ret int %res +} + +long %test7(bool %A) { + %c1 = cast bool %A to int + %res = cast int %c1 to long + ret long %res +} + +long %test8(sbyte %A) { + %c1 = cast sbyte %A to ulong + %res = cast ulong %c1 to long + ret long %res +} + +short %test9(short %A) { + %c1 = cast short %A to int + %c2 = cast int %c1 to short + ret short %c2 +} + +short %test10(short %A) { + %c1 = cast short %A to uint + %c2 = cast uint %c1 to short + ret short %c2 +} + +declare void %varargs(int, ...) + +void %test11(int* %P) { + %c = cast int* %P to short* + call void(int, ...)* %varargs(int 5, short* %c) + ret void +} + +int* %test12() { + %p = malloc [4 x sbyte] + %c = cast [4 x sbyte]* %p to int* + ret int* %c +} + +ubyte *%test13(long %A) { + %c = getelementptr [0 x ubyte]* cast ([32832 x ubyte]* %inbuf to [0 x ubyte]*), long 0, long %A + ret ubyte* %c +} + +bool %test14(sbyte %A) { + %c = cast sbyte %A to ubyte + %X = setlt ubyte %c, 128 ; setge %A, 0 + ret bool %X +} + +; This just won't occur when there's no difference between ubyte and sbyte +;bool %test15(ubyte %A) { +; %c = cast ubyte %A to sbyte +; %X = setlt sbyte %c, 0 ; setgt %A, 127 +; ret bool %X +;} + +bool %test16(int* %P) { + %c = cast int* %P to bool ;; setne P, null + ret bool %c +} + +short %test17(bool %tmp3) { + %c = cast bool %tmp3 to int + %t86 = cast int %c to short + ret short %t86 +} + +short %test18(sbyte %tmp3) { + %c = cast sbyte %tmp3 to int + %t86 = cast int %c to short + ret short %t86 +} + +bool %test19(int %X) { + %c = cast int %X to long + %Z = setlt long %c, 12345 + ret bool %Z +} + +bool %test20(bool %B) { + %c = cast bool %B to int + %D = setlt int %c, -1 + ret bool %D ;; false +} + +uint %test21(uint %X) { + %c1 = cast uint %X to sbyte + %c2 = cast sbyte %c1 to uint ;; sext -> zext -> and -> nop + %RV = and uint %c2, 255 + ret uint %RV +} + +uint %test22(uint %X) { + %c1 = cast uint %X to sbyte + %c2 = cast sbyte %c1 to uint ;; sext -> zext -> and -> nop + %RV = shl uint %c2, ubyte 24 + ret uint %RV +} + +int %test23(int %X) { + %c1 = cast int %X to ushort ;; Turn into an AND even though X + %c2 = cast ushort %c1 to int ;; and Z are signed. + ret int %c2 +} + +bool %test24(bool %C) { + %X = select bool %C, uint 14, uint 1234 + %c = cast uint %X to bool ;; Fold cast into select + ret bool %c +} + +void %test25(int** %P) { + %c = cast int** %P to float** + store float* null, float** %c ;; Fold cast into null + ret void +} + +int %test26(float %F) { + %c = cast float %F to double ;; no need to cast from float->double. + %D = cast double %c to int + ret int %D +} + +[4 x float]* %test27([9 x [4 x float]]* %A) { + %c = cast [9 x [4 x float]]* %A to [4 x float]* + ret [4 x float]* %c +} + +float* %test28([4 x float]* %A) { + %c = cast [4 x float]* %A to float* + ret float* %c +} + +uint %test29(uint %c1, uint %c2) { + %tmp1 = cast uint %c1 to ubyte + %tmp4.mask = cast uint %c2 to ubyte + %tmp = or ubyte %tmp4.mask, %tmp1 + %tmp10 = cast ubyte %tmp to uint + ret uint %tmp10 +} + +uint %test30(uint %c1) { + %c2 = cast uint %c1 to ubyte + %c3 = xor ubyte %c2, 1 + %c4 = cast ubyte %c3 to uint + ret uint %c4 +} + +bool %test31(ulong %A) { + %B = cast ulong %A to int + %C = and int %B, 42 + %D = seteq int %C, 10 + ret bool %D +} + + +void %test32(double** %tmp) { + %tmp8 = malloc [16 x sbyte] + %tmp8 = cast [16 x sbyte]* %tmp8 to double* + store double* %tmp8, double** %tmp + ret void +} + +uint %test33(uint %c1) { + %x = bitcast uint %c1 to float + %y = bitcast float %x to uint + ret uint %y +} + +ushort %test34(ushort %a) { + %c1 = zext ushort %a to int + %tmp21 = lshr int %c1, ubyte 8 + %c2 = trunc int %tmp21 to ushort + ret ushort %c2 +} + +ushort %test35(ushort %a) { + %c1 = bitcast ushort %a to short + %tmp2 = lshr short %c1, ubyte 8 + %c2 = bitcast short %tmp2 to ushort + ret ushort %c2 +} + diff --git a/llvm/test/Transforms/InstCombine/cast_ptr.ll b/llvm/test/Transforms/InstCombine/cast_ptr.ll new file mode 100644 index 00000000000..19d3ca6f8e8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/cast_ptr.ll @@ -0,0 +1,15 @@ +; Tests to make sure elimination of casts is working correctly +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep '\([sz]ext\)\|\(trunc\)' + +target pointersize = 32 + +implementation + +sbyte* %test1(sbyte* %t) { + %tmpc = cast sbyte* %t to uint + %tmpa = add uint %tmpc, 32 + %tv = cast uint %tmpa to sbyte* + ret sbyte* %tv +} + diff --git a/llvm/test/Transforms/InstCombine/deadcode.ll b/llvm/test/Transforms/InstCombine/deadcode.ll new file mode 100644 index 00000000000..836d6147f23 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/deadcode.ll @@ -0,0 +1,12 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'ret i32 %A' + +int %test(int %A) { + %X = or bool false, false + br bool %X, label %T, label %C +T: + %B = add int %A, 1 + br label %C +C: + %C = phi int [%B, %T], [%A, %0] + ret int %C +} diff --git a/llvm/test/Transforms/InstCombine/dg.exp b/llvm/test/Transforms/InstCombine/dg.exp new file mode 100644 index 00000000000..142de8a6c8f --- /dev/null +++ b/llvm/test/Transforms/InstCombine/dg.exp @@ -0,0 +1,3 @@ +load_lib llvm-dg.exp + +llvm-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.{ll,llx,c,cpp,tr}]] $objdir $srcdir $subdir $target_triplet $llvmgcc $llvmgxx $prcontext $llvmgcc_version diff --git a/llvm/test/Transforms/InstCombine/div.ll b/llvm/test/Transforms/InstCombine/div.ll new file mode 100644 index 00000000000..18d93c2a76d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/div.ll @@ -0,0 +1,68 @@ +; This test makes sure that div instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep div + +implementation + +int %test1(int %A) { + %B = div int %A, 1 + ret int %B +} + +uint %test2(uint %A) { + %B = div uint %A, 8 ; => Shift + ret uint %B +} + +int %test3(int %A) { + %B = div int 0, %A ; => 0, don't need to keep traps + ret int %B +} + +int %test4(int %A) { + %B = div int %A, -1 ; 0-A + ret int %B +} + +uint %test5(uint %A) { + %B = div uint %A, 4294967280 + %C = div uint %B, 4294967292 + ret uint %C +} + +bool %test6(uint %A) { + %B = div uint %A, 123 + %C = seteq uint %B, 0 ; A < 123 + ret bool %C +} + +bool %test7(uint %A) { + %B = div uint %A, 10 + %C = seteq uint %B, 2 ; A >= 20 && A < 30 + ret bool %C +} + +bool %test8(ubyte %A) { + %B = div ubyte %A, 123 + %C = seteq ubyte %B, 2 ; A >= 246 + ret bool %C +} + +bool %test9(ubyte %A) { + %B = div ubyte %A, 123 + %C = setne ubyte %B, 2 ; A < 246 + ret bool %C +} + +uint %test10(uint %X, bool %C) { + %V = select bool %C, uint 64, uint 8 + %R = udiv uint %X, %V + ret uint %R +} + +int %test11(int %X, bool %C) { + %A = select bool %C, int 1024, int 32 + %B = udiv int %X, %A + ret int %B +} diff --git a/llvm/test/Transforms/InstCombine/fpcast.ll b/llvm/test/Transforms/InstCombine/fpcast.ll new file mode 100644 index 00000000000..1da8e42edf4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/fpcast.ll @@ -0,0 +1,14 @@ +; Test some floating point casting cases +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | notcast +; RUN: llvm-upgrade %s -o - | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'ret i8 \(-1\)\|\(255\)' + +sbyte %test1() { + %x = fptoui float 255.0 to sbyte + ret sbyte %x +} + +ubyte %test2() { + %x = fptosi float -1.0 to ubyte + ret ubyte %x +} diff --git a/llvm/test/Transforms/InstCombine/getelementptr-setcc.ll b/llvm/test/Transforms/InstCombine/getelementptr-setcc.ll new file mode 100644 index 00000000000..4b637f2cfb1 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/getelementptr-setcc.ll @@ -0,0 +1,32 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep getelementptr + +bool %test1(short* %P, int %I, int %J) { + %X = getelementptr short* %P, int %I + %Y = getelementptr short* %P, int %J + + %C = setlt short* %X, %Y + ret bool %C +} + +bool %test2(short* %P, int %I) { + %X = getelementptr short* %P, int %I + + %C = setlt short* %X, %P + ret bool %C +} + +int %test3(int* %P, int %A, int %B) { + %tmp.4 = getelementptr int* %P, int %A ; <int*> [#uses=1] + %tmp.9 = getelementptr int* %P, int %B ; <int*> [#uses=1] + %tmp.10 = seteq int* %tmp.4, %tmp.9 ; <bool> [#uses=1] + %tmp.11 = cast bool %tmp.10 to int ; <int> [#uses=1] + ret int %tmp.11 +} + +int %test4(int* %P, int %A, int %B) { + %tmp.4 = getelementptr int* %P, int %A ; <int*> [#uses=1] + %tmp.6 = seteq int* %tmp.4, %P ; <bool> [#uses=1] + %tmp.7 = cast bool %tmp.6 to int ; <int> [#uses=1] + ret int %tmp.7 +} + diff --git a/llvm/test/Transforms/InstCombine/getelementptr.ll b/llvm/test/Transforms/InstCombine/getelementptr.ll new file mode 100644 index 00000000000..53a2892dc74 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/getelementptr.ll @@ -0,0 +1,73 @@ +; The %A getelementptr instruction should be eliminated here + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v '%B' | not grep getelementptr + +%Global = constant [10 x sbyte] c"helloworld" + +implementation + +int *%foo1(int* %I) { ; Test noop elimination + %A = getelementptr int* %I, long 0 + ret int * %A +} + +int* %foo2(int* %I) { ; Test noop elimination + %A = getelementptr int* %I + ret int* %A +} +int* %foo3(int * %I) { ; Test that two array indexing geps fold + %A = getelementptr int* %I, long 17 + %B = getelementptr int* %A, long 4 + ret int* %B +} + +int* %foo4({int} *%I) { ; Test that two getelementptr insts fold + %A = getelementptr {int}* %I, long 1 + %B = getelementptr {int}* %A, long 0, uint 0 + ret int* %B +} + +void %foo5(sbyte %B) { + ; This should be turned into a constexpr instead of being an instruction + %A = getelementptr [10 x sbyte]* %Global, long 0, long 4 + store sbyte %B, sbyte* %A + ret void +} + +int* %foo6() { + %M = malloc [4 x int] + %A = getelementptr [4 x int]* %M, long 0, long 0 + %B = getelementptr int* %A, long 2 + ret int* %B +} + +int* %foo7(int* %I, long %C, long %D) { + %A = getelementptr int* %I, long %C + %B = getelementptr int* %A, long %D + ret int* %B +} + +sbyte* %foo8([10 x int]* %X) { + %A = getelementptr [10 x int]* %X, long 0, long 0 ;; Fold into the cast. + %B = cast int* %A to sbyte* + ret sbyte * %B +} + +int %test9() { + %A = getelementptr {int, double}* null, int 0, uint 1 + %B = cast double* %A to int + ret int %B +} + +bool %test10({int, int} * %x, {int, int} * %y) { + %tmp.1 = getelementptr {int,int}* %x, int 0, uint 1 + %tmp.3 = getelementptr {int,int}* %y, int 0, uint 1 + %tmp.4 = seteq int* %tmp.1, %tmp.3 ;; seteq x, y + ret bool %tmp.4 +} + +bool %test11({int,int} *%X) { + %P = getelementptr {int,int}* %X, int 0, uint 0 + %Q = seteq int* %P, null + ret bool %Q +} diff --git a/llvm/test/Transforms/InstCombine/getelementptr_cast.ll b/llvm/test/Transforms/InstCombine/getelementptr_cast.ll new file mode 100644 index 00000000000..9d629d3bad3 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/getelementptr_cast.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast '' 'getelementptr.*' +%G = external global [3 x sbyte] + +implementation + +ubyte *%foo(uint %Idx) { + %tmp = getelementptr ubyte* cast ([3 x sbyte]* %G to ubyte*), uint %Idx + ret ubyte* %tmp +} diff --git a/llvm/test/Transforms/InstCombine/getelementptr_const.ll b/llvm/test/Transforms/InstCombine/getelementptr_const.ll new file mode 100644 index 00000000000..9a078c50fd1 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/getelementptr_const.ll @@ -0,0 +1,13 @@ +; Test folding of constantexpr geps into normal geps. +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -gcse -instcombine | llvm-dis | not grep getelementptr + +%Array = external global [40 x int] + +int %test(long %X) { + %A = getelementptr int* getelementptr ([40 x int]* %Array, long 0, long 0), long %X + %B = getelementptr [40 x int]* %Array, long 0, long %X + %a = cast int* %A to int + %b = cast int* %B to int + %c = sub int %a, %b + ret int %c +} diff --git a/llvm/test/Transforms/InstCombine/getelementptr_index.ll b/llvm/test/Transforms/InstCombine/getelementptr_index.ll new file mode 100644 index 00000000000..c4a7317bdeb --- /dev/null +++ b/llvm/test/Transforms/InstCombine/getelementptr_index.ll @@ -0,0 +1,10 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep trunc + +target endian = little +target pointersize = 32 + +int* %test(int* %X, long %Idx) { + ; Should insert a cast to int on this target + %R = getelementptr int* %X, long %Idx + ret int* %R +} diff --git a/llvm/test/Transforms/InstCombine/hoist_instr.ll b/llvm/test/Transforms/InstCombine/hoist_instr.ll new file mode 100644 index 00000000000..4059563dc23 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/hoist_instr.ll @@ -0,0 +1,16 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | %prcontext div 1 | grep then: + +;; This tests that the div is hoisted into the then block. + +int %foo(bool %C, int %A, int %B) { +entry: + br bool %C, label %then, label %endif + +then: + br label %endif + +endif: + %X = phi int [%A, %then], [15, %entry] + %Y = div int %X, 42 + ret int %Y +} diff --git a/llvm/test/Transforms/InstCombine/load.ll b/llvm/test/Transforms/InstCombine/load.ll new file mode 100644 index 00000000000..58f9894903b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/load.ll @@ -0,0 +1,74 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep load + +%X = constant int 42 +%X2 = constant int 47 +%Y = constant [2 x { int, float }] [ { int, float } { int 12, float 1.0 }, + { int, float } { int 37, float 1.2312 } ] +%Z = constant [2 x { int, float }] zeroinitializer + +int %test1() { + %B = load int* %X + ret int %B +} + +float %test2() { + %A = getelementptr [2 x { int, float}]* %Y, long 0, long 1, uint 1 + %B = load float* %A + ret float %B +} + + +int %test3() { + %A = getelementptr [2 x { int, float}]* %Y, long 0, long 0, uint 0 + %B = load int* %A + ret int %B +} + +int %test4() { + %A = getelementptr [2 x { int, float}]* %Z, long 0, long 1, uint 0 + %B = load int* %A + ret int %B +} + +; load (select (Cond, &V1, &V2)) --> select(Cond, load &V1, load &V2) +int %test5(bool %C) { + %Y = select bool %C, int* %X, int* %X2 + %Z = load int* %Y + ret int %Z +} + +int %test7(int %X) { + %V = getelementptr int* null, int %X + %R = load int* %V + ret int %R +} + +int %test8(int* %P) { + store int 1, int* %P + %X = load int* %P ;; Trivial store->load forwarding + ret int %X +} + +int %test9(int* %P) { + %X = load int* %P ;; Trivial load cse + %Y = load int* %P + %Z = sub int %X, %Y + ret int %Z +} + +int %test10(bool %C, int* %P, int* %Q) { + br bool %C, label %T, label %F +T: + store int 1, int* %Q + store int 0, int* %P + br label %C +F: + store int 0, int* %P + br label %C +C: + %V = load int* %P ;; always 0 + ret int %V +} diff --git a/llvm/test/Transforms/InstCombine/malloc.ll b/llvm/test/Transforms/InstCombine/malloc.ll new file mode 100644 index 00000000000..34fdfe862e8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/malloc.ll @@ -0,0 +1,7 @@ +; test that malloc's with a constant argument are promoted to array allocations +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep getelementptr + +int* %test() { + %X = malloc int, uint 4 + ret int* %X +} diff --git a/llvm/test/Transforms/InstCombine/memmove.ll b/llvm/test/Transforms/InstCombine/memmove.ll new file mode 100644 index 00000000000..fb20dbc873c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/memmove.ll @@ -0,0 +1,23 @@ +; This test makes sure that memmove instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'call void %llvm.memmove' + +%S = internal constant [33 x sbyte] c"panic: restorelist inconsistency\00" + +implementation + +declare void %llvm.memmove(sbyte*, sbyte*, uint, uint) + +void %test1(sbyte* %A, sbyte* %B, uint %N) { + ;; 0 bytes -> noop. + call void %llvm.memmove(sbyte* %A, sbyte* %B, uint 0, uint 1) + ret void +} + +void %test2(sbyte *%A, uint %N) { + ;; dest can't alias source since we can't write to source! + call void %llvm.memmove(sbyte* %A, sbyte* getelementptr ([33 x sbyte]* %S, int 0, int 0), + uint %N, uint 1) + ret void +} diff --git a/llvm/test/Transforms/InstCombine/mul.ll b/llvm/test/Transforms/InstCombine/mul.ll new file mode 100644 index 00000000000..ccec6b894a7 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/mul.ll @@ -0,0 +1,74 @@ +; This test makes sure that mul instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep mul + +implementation + +int %test1(int %A) { + %B = mul int %A, 1 + ret int %B +} + +int %test2(int %A) { + %B = mul int %A, 2 ; Should convert to an add instruction + ret int %B +} + +int %test3(int %A) { + %B = mul int %A, 0 ; This should disappear entirely + ret int %B +} + +double %test4(double %A) { + %B = mul double 1.0, %A ; This is safe for FP + ret double %B +} + +int %test5(int %A) { + %B = mul int %A, 8 + ret int %B +} + +ubyte %test6(ubyte %A) { + %B = mul ubyte %A, 8 + %C = mul ubyte %B, 8 + ret ubyte %C +} + +int %test7(int %i) { + %tmp = mul int %i, -1 ; %tmp = sub 0, %i + ret int %tmp +} + +ulong %test8(ulong %i) { + %j = mul ulong %i, 18446744073709551615 ; tmp = sub 0, %i + ret ulong %j +} + +uint %test9(uint %i) { + %j = mul uint %i, 4294967295 ; %j = sub 0, %i + ret uint %j +} + +uint %test10(int %a, uint %b) { + %c = setlt int %a, 0 + %d = cast bool %c to uint + %e = mul uint %d, %b ; e = b & (a >> 31) + ret uint %e +} + +uint %test11(int %a, uint %b) { + %c = setle int %a, -1 + %d = cast bool %c to uint + %e = mul uint %d, %b ; e = b & (a >> 31) + ret uint %e +} + +uint %test11(ubyte %a, uint %b) { + %c = setgt ubyte %a, 127 + %d = cast bool %c to uint + %e = mul uint %d, %b ; e = b & (a >> 31) + ret uint %e +} + diff --git a/llvm/test/Transforms/InstCombine/narrow.ll b/llvm/test/Transforms/InstCombine/narrow.ll new file mode 100644 index 00000000000..bff2b88a5db --- /dev/null +++ b/llvm/test/Transforms/InstCombine/narrow.ll @@ -0,0 +1,18 @@ +; This file contains various testcases that check to see that instcombine +; is narrowing computations when possible. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'ret i1 false' + +; test1 - Eliminating the casts in this testcase (by narrowing the AND +; operation) allows instcombine to realize the function always returns false. +; +bool %test1(int %A, int %B) { + %C1 = setlt int %A, %B + %ELIM1 = zext bool %C1 to uint + %C2 = setgt int %A, %B + %ELIM2 = zext bool %C2 to uint + %C3 = and uint %ELIM1, %ELIM2 + %ELIM3 = trunc uint %C3 to bool + ret bool %ELIM3 +} diff --git a/llvm/test/Transforms/InstCombine/not.ll b/llvm/test/Transforms/InstCombine/not.ll new file mode 100644 index 00000000000..3e85692500e --- /dev/null +++ b/llvm/test/Transforms/InstCombine/not.ll @@ -0,0 +1,45 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep xor + +implementation + +int %test1(int %A) { + %B = xor int %A, -1 + %C = xor int %B, -1 + ret int %C +} + +bool %test2(int %A, int %B) { + %cond = setle int %A, %B ; Can change into setge + %Ret = xor bool %cond, true + ret bool %Ret +} + + +; Test that demorgans law can be instcombined +int %test3(int %A, int %B) { + %a = xor int %A, -1 + %b = xor int %B, -1 + %c = and int %a, %b + %d = xor int %c, -1 + ret int %d +} + +; Test that demorgens law can work with constants +int %test4(int %A, int %B) { + %a = xor int %A, -1 + %c = and int %a, 5 ; 5 = ~c2 + %d = xor int %c, -1 + ret int %d +} + +; test the mirror of demorgans law... +int %test5(int %A, int %B) { + %a = xor int %A, -1 + %b = xor int %B, -1 + %c = or int %a, %b + %d = xor int %c, -1 + ret int %d +} diff --git a/llvm/test/Transforms/InstCombine/or.ll b/llvm/test/Transforms/InstCombine/or.ll new file mode 100644 index 00000000000..933f5f006a4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/or.ll @@ -0,0 +1,158 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v xor | not grep 'or ' + +implementation + +int %test1(int %A) { + %B = or int %A, 0 + ret int %B +} + +int %test2(int %A) { + %B = or int %A, -1 + ret int %B +} + +ubyte %test2a(ubyte %A) { + %B = or ubyte %A, 255 + ret ubyte %B +} + +bool %test3(bool %A) { + %B = or bool %A, false + ret bool %B +} + +bool %test4(bool %A) { + %B = or bool %A, true + ret bool %B +} + +bool %test5(bool %A) { + %B = or bool %A, %A + ret bool %B +} + +int %test6(int %A) { + %B = or int %A, %A + ret int %B +} + +int %test7(int %A) { ; A | ~A == -1 + %NotA = xor int -1, %A + %B = or int %A, %NotA + ret int %B +} + +ubyte %test8(ubyte %A) { + %B = or ubyte %A, 254 + %C = or ubyte %B, 1 + ret ubyte %C +} + +ubyte %test9(ubyte %A, ubyte %B) { ; Test that (A|c1)|(B|c2) == (A|B)|(c1|c2) + %C = or ubyte %A, 1 + %D = or ubyte %B, 254 + %E = or ubyte %C, %D + ret ubyte %E +} + +ubyte %test10(ubyte %A) { + %B = or ubyte %A, 1 + %C = and ubyte %B, 254 + %D = or ubyte %C, 254 ; (X & C1) | C2 --> (X | C2) & (C1|C2) + ret ubyte %D +} + +ubyte %test11(ubyte %A) { + %B = or ubyte %A, 254 + %C = xor ubyte %B, 13 + %D = or ubyte %C, 1 ; (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) + %E = xor ubyte %D, 12 + ret ubyte %E +} + +uint %test12(uint %A) { + %B = or uint %A, 4 ; Should be eliminated + %C = and uint %B, 8 + ret uint %C +} + +uint %test13(uint %A) { + %B = or uint %A, 12 + %C = and uint %B, 8 ; Always equal to 8 + ret uint %C +} + +bool %test14(uint %A, uint %B) { + %C1 = setlt uint %A, %B + %C2 = setgt uint %A, %B + %D = or bool %C1, %C2 ; (A < B) | (A > B) === A != B + ret bool %D +} + +bool %test15(uint %A, uint %B) { + %C1 = setlt uint %A, %B + %C2 = seteq uint %A, %B + %D = or bool %C1, %C2 ; (A < B) | (A == B) === A <= B + ret bool %D +} + +int %test16(int %A) { + %B = and int %A, 1 + %C = and int %A, -2 ; -2 = ~1 + %D = or int %B, %C ; %D = and int %B, -1 == %B + ret int %D +} + +int %test17(int %A) { + %B = and int %A, 1 + %C = and int %A, 4 + %D = or int %B, %C ; %D = and int %B, 5 + ret int %D +} + +bool %test18(int %A) { + %B = setge int %A, 100 + %C = setlt int %A, 50 + %D = or bool %B, %C ;; (A-50) >u 50 + ret bool %D +} + +bool %test19(int %A) { + %B = seteq int %A, 50 + %C = seteq int %A, 51 + %D = or bool %B, %C ;; (A-50) < 2 + ret bool %D +} + +int %test20(int %x) { + %y = and int %x, 123 + %z = or int %y, %x + ret int %z +} + +uint %test21(uint %tmp.1) { + %tmp.1.mask1 = add uint %tmp.1, 2 + %tmp.3 = and uint %tmp.1.mask1, 4294967294 + %tmp.5 = and uint %tmp.1, 1 + %tmp.6 = or uint %tmp.5, %tmp.3 ;; add tmp.1, 2 + ret uint %tmp.6 +} + +int %test22(int %B) { + %ELIM41 = and int %B, 1 ; <int> [#uses=1] + %ELIM7 = and int %B, -2 ; <int> [#uses=1] + %ELIM5 = or int %ELIM41, %ELIM7 ; <int> [#uses=1] + ret int %ELIM5 +} + +ushort %test23(ushort %A) { + %B = shr ushort %A, ubyte 1 + %C = or ushort %B, 32768 ;; fold or into xor + %D = xor ushort %C, 8193 + ret ushort %D +} diff --git a/llvm/test/Transforms/InstCombine/phi.ll b/llvm/test/Transforms/InstCombine/phi.ll new file mode 100644 index 00000000000..44841b76431 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/phi.ll @@ -0,0 +1,79 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep phi + +implementation + +int %test1(int %A, bool %b) { +BB0: br bool %b, label %BB1, label %BB2 +BB1: + %B = phi int [%A, %BB0] ; Combine away one argument PHI nodes + ret int %B +BB2: + ret int %A +} + +int %test2(int %A, bool %b) { +BB0: br bool %b, label %BB1, label %BB2 +BB1: + br label %BB2 +BB2: + %B = phi int [%A, %BB0], [%A, %BB1] ; Combine away PHI nodes with same values + ret int %B +} + +int %test3(int %A, bool %b) { +BB0: br label %Loop + +Loop: + %B = phi int [%A, %BB0], [%B, %Loop] ; PHI has same value always. + br bool %b, label %Loop, label %Exit +Exit: + ret int %B +} + +int %test4(bool %b) { +BB0: ret int 7 ; Loop is unreachable + +Loop: + %B = phi int [%B, %L2], [%B, %Loop] ; PHI has same value always. + br bool %b, label %L2, label %Loop +L2: + br label %Loop +} + +int %test5(int %A, bool %b) { +BB0: br label %Loop + +Loop: + %B = phi int [%A, %BB0], [undef, %Loop] ; PHI has same value always. + br bool %b, label %Loop, label %Exit +Exit: + ret int %B +} + +uint %test6(int %A, bool %b) { +BB0: + %X = cast int %A to uint + br bool %b, label %BB1, label %BB2 +BB1: + %Y = cast int %A to uint + br label %BB2 +BB2: + %B = phi uint [%X, %BB0], [%Y, %BB1] ;; Suck casts into phi + ret uint %B +} + +int %test7(int %A, bool %b) { +BB0: br label %Loop + +Loop: + %B = phi int [%A, %BB0], [%C, %Loop] ; PHI is dead. + %C = add int %B, 123 + br bool %b, label %Loop, label %Exit +Exit: + ret int 0 +} + diff --git a/llvm/test/Transforms/InstCombine/rem.ll b/llvm/test/Transforms/InstCombine/rem.ll new file mode 100644 index 00000000000..ccb358de4d8 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/rem.ll @@ -0,0 +1,79 @@ +; This test makes sure that these instructions are properly eliminated. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep rem + +implementation + +int %test1(int %A) { + %B = rem int %A, 1 ; ISA constant 0 + ret int %B +} + +int %test2(int %A) { ; 0 % X = 0, we don't need to preserve traps + %B = rem int 0, %A + ret int %B +} + +uint %test3(uint %A) { + %B = rem uint %A, 8 ; & 7 + ret uint %B +} + +bool %test3(int %A) { + %B = rem int %A, -8 ; & 7 + %C = setne int %B, 0 + ret bool %C +} + +uint %test4(uint %X, bool %C) { + %V = select bool %C, uint 1, uint 8 + %R = rem uint %X, %V + ret uint %R +} + +uint %test5(uint %X, ubyte %B) { + %Amt = shl uint 32, ubyte %B + %V = rem uint %X, %Amt + ret uint %V +} + +int %test6(int %A) { + %B = rem int %A, 0 ;; undef + ret int %B +} + +int %test7(int %A) { + %B = mul int %A, 26 + %C = rem int %B, 13 + ret int %C +} + +int %test8(int %A) { + %B = shl int %A, ubyte 4 + %C = rem int %B, 8 + ret int %C +} + +uint %test9(uint %A) { + %B = mul uint %A, 124 + %C = rem uint %B, 62 + ret uint %C +} + +int %test10(ubyte %c) { + %tmp.1 = cast ubyte %c to int + %tmp.2 = mul int %tmp.1, 3 + %tmp.3 = cast int %tmp.2 to ulong + %tmp.5 = rem ulong %tmp.3, 3 + %tmp.6 = cast ulong %tmp.5 to int + ret int %tmp.6 +} + +int %test11(int %i) { + %tmp.1 = and int %i, -2 + %tmp.3 = mul int %tmp.1, 3 + %tmp.5 = rem int %tmp.3, 6 + ret int %tmp.5 +} + diff --git a/llvm/test/Transforms/InstCombine/select.ll b/llvm/test/Transforms/InstCombine/select.ll new file mode 100644 index 00000000000..a9dd75d9ead --- /dev/null +++ b/llvm/test/Transforms/InstCombine/select.ll @@ -0,0 +1,181 @@ +; This test makes sure that these instructions are properly eliminated. + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep select && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output + +implementation + +int %test1(int %A, int %B) { + %C = select bool false, int %A, int %B + ret int %C +} + +int %test2(int %A, int %B) { + %C = select bool true, int %A, int %B + ret int %C +} + +int %test3(bool %C, int %I) { + %V = select bool %C, int %I, int %I ; V = I + ret int %V +} + +bool %test4(bool %C) { + %V = select bool %C, bool true, bool false ; V = C + ret bool %V +} + +bool %test5(bool %C) { + %V = select bool %C, bool false, bool true ; V = !C + ret bool %V +} + +int %test6(bool %C) { + %V = select bool %C, int 1, int 0 ; V = cast C to int + ret int %V +} + +bool %test7(bool %C, bool %X) { + %R = select bool %C, bool true, bool %X ; R = or C, X + ret bool %R +} + +bool %test8(bool %C, bool %X) { + %R = select bool %C, bool %X, bool false ; R = and C, X + ret bool %R +} + +bool %test9(bool %C, bool %X) { + %R = select bool %C, bool false, bool %X ; R = and !C, X + ret bool %R +} + +bool %test10(bool %C, bool %X) { + %R = select bool %C, bool %X, bool true ; R = or !C, X + ret bool %R +} + +int %test11(int %a) { + %C = seteq int %a, 0 + %R = select bool %C, int 0, int 1 + ret int %R +} + +int %test12(bool %cond, int %a) { + %b = or int %a, 1 + %c = select bool %cond, int %b, int %a + ret int %c +} + +int %test12a(bool %cond, int %a) { + %b = shr int %a, ubyte 1 + %c = select bool %cond, int %b, int %a + ret int %c +} + +int %test12b(bool %cond, int %a) { + %b = shr int %a, ubyte 1 + %c = select bool %cond, int %a, int %b + ret int %c +} + +int %test13(int %a, int %b) { + %C = seteq int %a, %b + %V = select bool %C, int %a, int %b + ret int %V +} + +int %test13a(int %a, int %b) { + %C = setne int %a, %b + %V = select bool %C, int %a, int %b + ret int %V +} + +int %test13b(int %a, int %b) { + %C = seteq int %a, %b + %V = select bool %C, int %b, int %a + ret int %V +} + +bool %test14a(bool %C, int %X) { + %V = select bool %C, int %X, int 0 + %R = setlt int %V, 1 ; (X < 1) | !C + ret bool %R +} + +bool %test14b(bool %C, int %X) { + %V = select bool %C, int 0, int %X + %R = setlt int %V, 1 ; (X < 1) | C + ret bool %R +} + +int %test15a(int %X) { ;; Code sequence for (X & 16) ? 16 : 0 + %t1 = and int %X, 16 + %t2 = seteq int %t1, 0 + %t3 = select bool %t2, int 0, int 16 ;; X & 16 + ret int %t3 +} + +int %test15b(int %X) { ;; Code sequence for (X & 32) ? 0 : 24 + %t1 = and int %X, 32 + %t2 = seteq int %t1, 0 + %t3 = select bool %t2, int 32, int 0 ;; ~X & 32 + ret int %t3 +} + +int %test15c(int %X) { ;; Alternate code sequence for (X & 16) ? 16 : 0 + %t1 = and int %X, 16 + %t2 = seteq int %t1, 16 + %t3 = select bool %t2, int 16, int 0 ;; X & 16 + ret int %t3 +} + +int %test15d(int %X) { ;; Alternate code sequence for (X & 16) ? 16 : 0 + %t1 = and int %X, 16 + %t2 = setne int %t1, 0 + %t3 = select bool %t2, int 16, int 0 ;; X & 16 + ret int %t3 +} + +int %test16(bool %C, int* %P) { + %P2 = select bool %C, int* %P, int* null + %V = load int* %P2 + ret int %V +} + +bool %test17(int* %X, bool %C) { + %R = select bool %C, int* %X, int* null + %RV = seteq int* %R, null + ret bool %RV +} + +int %test18(int %X, int %Y, bool %C) { + %R = select bool %C, int %X, int 0 + %V = div int %Y, %R ; div Y,X + ret int %V +} + +int %test19(uint %x) { + %tmp = setgt uint %x, 2147483647 + %retval = select bool %tmp, int -1, int 0 + ret int %retval +} + +int %test20(int %x) { + %tmp = setlt int %x, 0 + %retval = select bool %tmp, int -1, int 0 + ret int %retval +} + +long %test21(int %x) { + %tmp = setlt int %x, 0 + %retval = select bool %tmp, long -1, long 0 + ret long %retval +} + +short %test22(int %x) { + %tmp = setlt int %x, 0 + %retval = select bool %tmp, short -1, short 0 + ret short %retval +} + diff --git a/llvm/test/Transforms/InstCombine/set.ll b/llvm/test/Transforms/InstCombine/set.ll new file mode 100644 index 00000000000..ca1ccffe6b4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/set.ll @@ -0,0 +1,147 @@ +; This test makes sure that these instructions are properly eliminated. +; +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep icmp + +%X = uninitialized global int + +bool %test1(int %A) { + %B = seteq int %A, %A + %C = seteq int* %X, null ; Never true + %D = and bool %B, %C + ret bool %D +} + +bool %test2(int %A) { + %B = setne int %A, %A + %C = setne int* %X, null ; Never false + %D = or bool %B, %C + ret bool %D +} + +bool %test3(int %A) { + %B = setlt int %A, %A + ret bool %B +} + +bool %test4(int %A) { + %B = setgt int %A, %A + ret bool %B +} + +bool %test5(int %A) { + %B = setle int %A, %A + ret bool %B +} + +bool %test6(int %A) { + %B = setge int %A, %A + ret bool %B +} + +bool %test7(uint %A) { + %B = setge uint %A, 0 ; true + ret bool %B +} + +bool %test8(uint %A) { + %B = setlt uint %A, 0 ; false + ret bool %B +} + +;; test operations on boolean values these should all be eliminated$a +bool %test9(bool %A) { + %B = setlt bool %A, false ; false + ret bool %B +} +bool %test10(bool %A) { + %B = setgt bool %A, true ; false + ret bool %B +} +bool %test11(bool %A) { + %B = setle bool %A, true ; true + ret bool %B +} +bool %test12(bool %A) { + %B = setge bool %A, false ; true + ret bool %B +} +bool %test13(bool %A, bool %B) { + %C = setge bool %A, %B ; A | ~B + ret bool %C +} +bool %test14(bool %A, bool %B) { + %C = seteq bool %A, %B ; ~(A ^ B) + ret bool %C +} + +bool %test16(uint %A) { + %B = and uint %A, 5 + %C = seteq uint %B, 8 ; Is never true + ret bool %C +} + +bool %test17(ubyte %A) { + %B = or ubyte %A, 1 + %C = seteq ubyte %B, 2 ; Always false + ret bool %C +} + +bool %test18(bool %C, int %a) { +entry: + br bool %C, label %endif, label %else + +else: + br label %endif + +endif: + %b.0 = phi int [ 0, %entry ], [ 1, %else ] + %tmp.4 = setlt int %b.0, 123 + ret bool %tmp.4 +} + +bool %test19(bool %A, bool %B) { + %a = cast bool %A to int + %b = cast bool %B to int + %C = seteq int %a, %b + ret bool %C +} + +uint %test20(uint %A) { + %B = and uint %A, 1 + %C = setne uint %B, 0 + %D = cast bool %C to uint + ret uint %D +} + +int %test21(int %a) { + %tmp.6 = and int %a, 4 + %not.tmp.7 = setne int %tmp.6, 0 + %retval = cast bool %not.tmp.7 to int + ret int %retval +} + +bool %test22(uint %A, int %X) { + %B = and uint %A, 100663295 + %C = setlt uint %B, 268435456 + %Y = and int %X, 7 + %Z = setgt int %Y, -1 + %R = or bool %C, %Z + ret bool %R +} + +int %test23(int %a) { + %tmp.1 = and int %a, 1 + %tmp.2 = seteq int %tmp.1, 0 + %tmp.3 = cast bool %tmp.2 to int ;; xor tmp1, 1 + ret int %tmp.3 +} + +int %test24(uint %a) { + %tmp1 = and uint %a, 4 + %tmp.1 = shr uint %tmp1, ubyte 2 + %tmp.2 = seteq uint %tmp.1, 0 + %tmp.3 = cast bool %tmp.2 to int ;; xor tmp1, 1 + ret int %tmp.3 +} + diff --git a/llvm/test/Transforms/InstCombine/setcc-cast-cast.ll b/llvm/test/Transforms/InstCombine/setcc-cast-cast.ll new file mode 100644 index 00000000000..a25fa0c37d4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/setcc-cast-cast.ll @@ -0,0 +1,42 @@ +; This test case was reduced from MultiSource/Applications/hbd. It makes sure +; that folding doesn't happen in case a zext is applied where a sext should have +; been when a setcc is used with two casts. +; RUN: llvm-upgrade < %s | llvm-as | llc -instcombine | llvm-dis | not grep 'br bool false' +int %bug(ubyte %inbuff) { +entry: + %tmp = bitcast ubyte %inbuff to sbyte ; <sbyte> [#uses=1] + %tmp = sext sbyte %tmp to int ; <int> [#uses=3] + %tmp = seteq int %tmp, 1 ; <bool> [#uses=1] + br bool %tmp, label %cond_true, label %cond_next + +cond_true: ; preds = %entry + br label %bb + +cond_next: ; preds = %entry + %tmp3 = seteq int %tmp, -1 ; <bool> [#uses=1] + br bool %tmp3, label %cond_true4, label %cond_next5 + +cond_true4: ; preds = %cond_next + br label %bb + +cond_next5: ; preds = %cond_next + %tmp7 = setgt int %tmp, 1 ; <bool> [#uses=1] + br bool %tmp7, label %cond_true8, label %cond_false + +cond_true8: ; preds = %cond_next5 + br label %cond_next9 + +cond_false: ; preds = %cond_next5 + br label %cond_next9 + +cond_next9: ; preds = %cond_false, %cond_true8 + %iftmp.1.0 = phi int [ 42, %cond_true8 ], [ 23, %cond_false ] ; <int> [#uses=1] + br label %return + +bb: ; preds = %cond_true4, %cond_true + br label %return + +return: ; preds = %bb, %cond_next9 + %retval.0 = phi int [ 17, %bb ], [ %iftmp.1.0, %cond_next9 ] ; <int> [#uses=1] + ret int %retval.0 +} diff --git a/llvm/test/Transforms/InstCombine/setcc-strength-reduce.ll b/llvm/test/Transforms/InstCombine/setcc-strength-reduce.ll new file mode 100644 index 00000000000..d38c6686d0b --- /dev/null +++ b/llvm/test/Transforms/InstCombine/setcc-strength-reduce.ll @@ -0,0 +1,31 @@ +; This test ensures that "strength reduction" of conditional expressions are +; working. Basically this boils down to converting setlt,gt,le,ge instructions +; into equivalent setne,eq instructions. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v 'icmp eq' | grep -v 'icmp ne' | not grep icmp + +bool %test1(uint %A) { + %B = setge uint %A, 1 ; setne %A, 0 + ret bool %B +} + +bool %test2(uint %A) { + %B = setgt uint %A, 0 ; setne %A, 0 + ret bool %B +} + +bool %test3(sbyte %A) { + %B = setge sbyte %A, -127 ; setne %A, -128 + ret bool %B +} + +bool %test4(sbyte %A) { + %B = setle sbyte %A, 126 ; setne %A, 127 + ret bool %B +} + +bool %test5(sbyte %A) { + %B = setlt sbyte %A, 127 ; setne %A, 127 + ret bool %B +} diff --git a/llvm/test/Transforms/InstCombine/shift-simplify.ll b/llvm/test/Transforms/InstCombine/shift-simplify.ll new file mode 100644 index 00000000000..ce19384d165 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/shift-simplify.ll @@ -0,0 +1,22 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | egrep 'shl|lshr|ashr' | wc -l | grep 3 + +int %test0(int %A, int %B, ubyte %C) { + %X = shl int %A, ubyte %C + %Y = shl int %B, ubyte %C + %Z = and int %X, %Y + ret int %Z +} + +int %test1(int %A, int %B, ubyte %C) { + %X = lshr int %A, ubyte %C + %Y = lshr int %B, ubyte %C + %Z = or int %X, %Y + ret int %Z +} + +int %test2(int %A, int %B, ubyte %C) { + %X = ashr int %A, ubyte %C + %Y = ashr int %B, ubyte %C + %Z = xor int %X, %Y + ret int %Z +} diff --git a/llvm/test/Transforms/InstCombine/shift-sra.ll b/llvm/test/Transforms/InstCombine/shift-sra.ll new file mode 100644 index 00000000000..a887d61196a --- /dev/null +++ b/llvm/test/Transforms/InstCombine/shift-sra.ll @@ -0,0 +1,17 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'lshr i32' | wc -l | grep 2 && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep ashr + +int %test1(int %X, ubyte %A) { + %Y = shr int %X, ubyte %A ; can be logical shift. + %Z = and int %Y, 1 + ret int %Z +} + +int %test2(ubyte %tmp) { + %tmp3 = cast ubyte %tmp to int + %tmp4 = add int %tmp3, 7 + %tmp5 = ashr int %tmp4, ubyte 3 ; lshr + ret int %tmp5 +} + diff --git a/llvm/test/Transforms/InstCombine/shift.ll b/llvm/test/Transforms/InstCombine/shift.ll new file mode 100644 index 00000000000..28c517018e4 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/shift.ll @@ -0,0 +1,190 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep sh + +implementation + +int %test1(int %A) { + %B = shl int %A, ubyte 0 + ret int %B +} + +int %test2(ubyte %A) { + %B = shl int 0, ubyte %A + ret int %B +} + +int %test3(int %A) { + %B = shr int %A, ubyte 0 + ret int %B +} + +int %test4(ubyte %A) { + %B = shr int 0, ubyte %A + ret int %B +} + +uint %test5(uint %A) { + %B = shr uint %A, ubyte 32 ;; shift all bits out + ret uint %B +} + +uint %test5a(uint %A) { + %B = shl uint %A, ubyte 32 ;; shift all bits out + ret uint %B +} + +uint %test6(uint %A) { + %B = shl uint %A, ubyte 1 ;; convert to an mul instruction + %C = mul uint %B, 3 + ret uint %C +} + +int %test7(ubyte %A) { + %B = shr int -1, ubyte %A ;; Always equal to -1 + ret int %B +} + +ubyte %test8(ubyte %A) { ;; (A << 5) << 3 === A << 8 == 0 + %B = shl ubyte %A, ubyte 5 + %C = shl ubyte %B, ubyte 3 + ret ubyte %C +} + +ubyte %test9(ubyte %A) { ;; (A << 7) >> 7 === A & 1 + %B = shl ubyte %A, ubyte 7 + %C = shr ubyte %B, ubyte 7 + ret ubyte %C +} + +ubyte %test10(ubyte %A) { ;; (A >> 7) << 7 === A & 128 + %B = shr ubyte %A, ubyte 7 + %C = shl ubyte %B, ubyte 7 + ret ubyte %C +} + +ubyte %test11(ubyte %A) { ;; (A >> 3) << 4 === (A & 0x1F) << 1 + %a = mul ubyte %A, 3 + %B = shr ubyte %a, ubyte 3 + %C = shl ubyte %B, ubyte 4 + ret ubyte %C +} + +int %test12(int %A) { + %B = shr int %A, ubyte 8 ;; (A >> 8) << 8 === A & -256 + %C = shl int %B, ubyte 8 + ret int %C +} + +sbyte %test13(sbyte %A) { ;; (A >> 3) << 4 === (A & -8) * 2 + %a = mul sbyte %A, 3 + %B = shr sbyte %a, ubyte 3 + %C = shl sbyte %B, ubyte 4 + ret sbyte %C +} + +uint %test14(uint %A) { + %B = shr uint %A, ubyte 4 + %C = or uint %B, 1234 + %D = shl uint %C, ubyte 4 ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4) + ret uint %D +} +uint %test14a(uint %A) { + %B = shl uint %A, ubyte 4 + %C = and uint %B, 1234 + %D = shr uint %C, ubyte 4 ;; D = ((B | 1234) << 4) === ((B << 4)|(1234 << 4) + ret uint %D +} + +int %test15(bool %C) { + %A = select bool %C, int 3, int 1 + %V = shl int %A, ubyte 2 + ret int %V +} + +int %test15a(bool %C) { + %A = select bool %C, ubyte 3, ubyte 1 + %V = shl int 64, ubyte %A + ret int %V +} + +bool %test16(int %X) { + %tmp.3 = shr int %X, ubyte 4 + %tmp.6 = and int %tmp.3, 1 + %tmp.7 = setne int %tmp.6, 0 ;; X & 16 != 0 + ret bool %tmp.7 +} + +bool %test17(uint %A) { + %B = shr uint %A, ubyte 3 + %C = seteq uint %B, 1234 + ret bool %C +} + +bool %test18(ubyte %A) { + %B = shr ubyte %A, ubyte 7 + %C = seteq ubyte %B, 123 ;; false + ret bool %C +} + +bool %test19(int %A) { + %B = shr int %A, ubyte 2 + %C = seteq int %B, 0 ;; (X & -4) == 0 + ret bool %C +} + +bool %test19a(int %A) { + %B = shr int %A, ubyte 2 + %C = seteq int %B, -1 ;; (X & -4) == -4 + ret bool %C +} + +bool %test20(sbyte %A) { + %B = shr sbyte %A, ubyte 7 + %C = seteq sbyte %B, 123 ;; false + ret bool %C +} + +bool %test21(ubyte %A) { + %B = shl ubyte %A, ubyte 4 + %C = seteq ubyte %B, 128 + ret bool %C +} + +bool %test22(ubyte %A) { + %B = shl ubyte %A, ubyte 4 + %C = seteq ubyte %B, 0 + ret bool %C +} + +sbyte %test23(int %A) { + %B = shl int %A, ubyte 24 ;; casts not needed + %C = shr int %B, ubyte 24 + %D = cast int %C to sbyte + ret sbyte %D +} + +sbyte %test24(sbyte %X) { + %Y = and sbyte %X, -5 ; ~4 + %Z = shl sbyte %Y, ubyte 5 + %Q = shr sbyte %Z, ubyte 5 + ret sbyte %Q +} + +uint %test25(uint %tmp.2, uint %AA) { + %x = shr uint %AA, ubyte 17 + %tmp.3 = shr uint %tmp.2, ubyte 17 ; <uint> [#uses=1] + %tmp.5 = add uint %tmp.3, %x ; <uint> [#uses=1] + %tmp.6 = shl uint %tmp.5, ubyte 17 ; <uint> [#uses=1] + ret uint %tmp.6 +} + +int %test26(uint %A) { ;; handle casts between shifts. + %B = shr uint %A, ubyte 1 + %C = cast uint %B to int + %D = shl int %C, ubyte 1 + ret int %D +} + diff --git a/llvm/test/Transforms/InstCombine/shl-trunc.ll b/llvm/test/Transforms/InstCombine/shl-trunc.ll new file mode 100644 index 00000000000..bfd41a87fc7 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/shl-trunc.ll @@ -0,0 +1,7 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep shl + +bool %test(int %X, ubyte %A) { + %B = lshr int %X, ubyte %A + %D = trunc int %B to bool + ret bool %D +} diff --git a/llvm/test/Transforms/InstCombine/signext.ll b/llvm/test/Transforms/InstCombine/signext.ll new file mode 100644 index 00000000000..7dcb466ad64 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/signext.ll @@ -0,0 +1,43 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep '(and\|xor\|add\|shl\|shr)' + +int %test1(int %x) { + %tmp.1 = and int %x, 65535 ; <int> [#uses=1] + %tmp.2 = xor int %tmp.1, -32768 ; <int> [#uses=1] + %tmp.3 = add int %tmp.2, 32768 ; <int> [#uses=1] + ret int %tmp.3 +} + +int %test2(int %x) { + %tmp.1 = and int %x, 65535 ; <int> [#uses=1] + %tmp.2 = xor int %tmp.1, 32768 ; <int> [#uses=1] + %tmp.3 = add int %tmp.2, -32768 ; <int> [#uses=1] + ret int %tmp.3 +} + +int %test3(ushort %P) { + %tmp.1 = cast ushort %P to int ; <int> [#uses=1] + %tmp.4 = xor int %tmp.1, 32768 ; <int> [#uses=1] + %tmp.5 = add int %tmp.4, -32768 ; <int> [#uses=1] + ret int %tmp.5 +} + +uint %test4(ushort %P) { + %tmp.1 = cast ushort %P to uint ; <uint> [#uses=1] + %tmp.4 = xor uint %tmp.1, 32768 ; <uint> [#uses=1] + %tmp.5 = add uint %tmp.4, 4294934528 ; <uint> [#uses=1] + ret uint %tmp.5 +} + +int %test5(int %x) { + %tmp.1 = and int %x, 254 + %tmp.2 = xor int %tmp.1, 128 + %tmp.3 = add int %tmp.2, -128 + ret int %tmp.3 +} + +int %test6(int %x) { + %tmp.2 = shl int %x, ubyte 16 ; <int> [#uses=1] + %tmp.4 = shr int %tmp.2, ubyte 16 ; <int> [#uses=1] + ret int %tmp.4 +} diff --git a/llvm/test/Transforms/InstCombine/sink_instruction.ll b/llvm/test/Transforms/InstCombine/sink_instruction.ll new file mode 100644 index 00000000000..a45c16163f7 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/sink_instruction.ll @@ -0,0 +1,17 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | %prcontext div 1 | grep ret + +;; This tests that the instructions in the entry blocks are sunk into each +;; arm of the 'if'. + +int %foo(bool %C, int %A, int %B) { +entry: + %tmp.2 = div int %A, %B + %tmp.9 = add int %B, %A + br bool %C, label %then, label %endif + +then: + ret int %tmp.9 + +endif: + ret int %tmp.2 +} diff --git a/llvm/test/Transforms/InstCombine/stacksaverestore.ll b/llvm/test/Transforms/InstCombine/stacksaverestore.ll new file mode 100644 index 00000000000..d9633b5c3be --- /dev/null +++ b/llvm/test/Transforms/InstCombine/stacksaverestore.ll @@ -0,0 +1,20 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep call + +;; Test that llvm.stackrestore is removed when possible. + +int* %test1(uint %P) { + %tmp = call sbyte* %llvm.stacksave() + call void %llvm.stackrestore(sbyte* %tmp) ;; not restoring anything + %A = alloca int, uint %P + ret int* %A +} + +void %test2(sbyte* %X) { + call void %llvm.stackrestore(sbyte* %X) ;; no allocas before return. + ret void +} + +declare sbyte* %llvm.stacksave() + +declare void %llvm.stackrestore(sbyte*) diff --git a/llvm/test/Transforms/InstCombine/store.ll b/llvm/test/Transforms/InstCombine/store.ll new file mode 100644 index 00000000000..2102fec100c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/store.ll @@ -0,0 +1,16 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep -v 'store.*,.*null' | not grep store + +void %test1(int* %P) { + store int undef, int* %P + store int 123, int* undef + store int 124, int* null + ret void +} + +void %test2(int* %P) { + %X = load int* %P + %Y = add int %X, 0 + store int %Y, int* %P + ret void +} diff --git a/llvm/test/Transforms/InstCombine/sub.ll b/llvm/test/Transforms/InstCombine/sub.ll new file mode 100644 index 00000000000..be38da97e1d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/sub.ll @@ -0,0 +1,140 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep -v 'sub i32 %Cok.s, %Bok.s' | not grep sub + +implementation + +int %test1(int %A) { + %B = sub int %A, %A ; ISA constant 0 + ret int %B +} + +int %test2(int %A) { + %B = sub int %A, 0 + ret int %B +} + +int %test3(int %A) { + %B = sub int 0, %A ; B = -A + %C = sub int 0, %B ; C = -B = A + ret int %C +} + +int %test4(int %A, int %x) { + %B = sub int 0, %A + %C = sub int %x, %B + ret int %C +} + +int %test5(int %A, int %Bok, int %Cok) { + %D = sub int %Bok, %Cok + %E = sub int %A, %D + ret int %E +} + +int %test6(int %A, int %B) { + %C = and int %A, %B ; A - (A & B) => A & ~B + %D = sub int %A, %C + ret int %D +} + +int %test7(int %A) { + %B = sub int -1, %A ; B = ~A + ret int %B +} + +int %test8(int %A) { + %B = mul int 9, %A + %C = sub int %B, %A ; C = 9*A-A == A*8 == A << 3 + ret int %C +} + +int %test9(int %A) { + %B = mul int 3, %A + %C = sub int %A, %B ; C = A-3*A == A*-2 + ret int %C +} + +int %test10(int %A, int %B) { ; -A*-B == A*B + %C = sub int 0, %A + %D = sub int 0, %B + %E = mul int %C, %D + ret int %E +} + +int %test10(int %A) { ; -A *c1 == A * -c1 + %C = sub int 0, %A + %E = mul int %C, 7 + ret int %E +} + +bool %test11(ubyte %A, ubyte %B) { + %C = sub ubyte %A, %B + %cD = setne ubyte %C, 0 ; == setne A, B + ret bool %cD +} + +int %test12(int %A) { + %B = shr int %A, ubyte 31 + %C = sub int 0, %B ; == ushr A, 31 + ret int %C +} + +uint %test13(uint %A) { + %B = shr uint %A, ubyte 31 + %C = sub uint 0, %B ; == sar A, 31 + ret uint %C +} + +int %test14(uint %A) { + %B = shr uint %A, ubyte 31 + %C = cast uint %B to int + %D = sub int 0, %C + ret int %D +} + +int %test15(int %A, int %B) { + %C = sub int 0, %A + %D = rem int %B, %C ;; X % -Y === X % Y + ret int %D +} + +int %test16(int %A) { + %X = div int %A, 1123 + %Y = sub int 0, %X + ret int %Y +} + +int %test17(int %A) { + %B = sub int 0, %A + %C = div int %B, 1234 + ret int %C +} + +long %test18(long %Y) { + %tmp.4 = shl long %Y, ubyte 2 + %tmp.12 = shl long %Y, ubyte 2 + %tmp.8 = sub long %tmp.4, %tmp.12 ;; 0 + ret long %tmp.8 +} + +int %test19(int %X, int %Y) { + %Z = sub int %X, %Y + %Q = add int %Z, %Y + ret int %Q +} + +bool %test20(int %g, int %h) { + %tmp.2 = sub int %g, %h + %tmp.4 = setne int %tmp.2, %g + ret bool %tmp.4 +} + +bool %test21(int %g, int %h) { + %tmp.2 = sub int %g, %h + %tmp.4 = setne int %tmp.2, %g + ret bool %tmp.4 +} + diff --git a/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll b/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll new file mode 100644 index 00000000000..9642ffda56c --- /dev/null +++ b/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll @@ -0,0 +1,30 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'sub float' && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'mul float' && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'insertelement.*0.00' && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'call.*llvm.x86.sse.mul' && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'call.*llvm.x86.sse.sub' + +ushort %Convert_sse(float %f) { +entry: + %tmp = insertelement <4 x float> undef, float %f, uint 0 ; <<4 x float>> [#uses=1] + %tmp10 = insertelement <4 x float> %tmp, float 0.000000e+00, uint 1 ; <<4 x float>> [#uses=1] + %tmp11 = insertelement <4 x float> %tmp10, float 0.000000e+00, uint 2 ; <<4 x float>> [#uses=1] + %tmp12 = insertelement <4 x float> %tmp11, float 0.000000e+00, uint 3 ; <<4 x float>> [#uses=1] + %tmp28 = tail call <4 x float> %llvm.x86.sse.sub.ss( <4 x float> %tmp12, <4 x float> < float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00 > ) ; <<4 x float>> [#uses=1] + %tmp37 = tail call <4 x float> %llvm.x86.sse.mul.ss( <4 x float> %tmp28, <4 x float> < float 5.000000e-01, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00 > ) ; <<4 x float>> [#uses=1] + %tmp48 = tail call <4 x float> %llvm.x86.sse.min.ss( <4 x float> %tmp37, <4 x float> < float 6.553500e+04, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00 > ) ; <<4 x float>> [#uses=1] + %tmp59 = tail call <4 x float> %llvm.x86.sse.max.ss( <4 x float> %tmp48, <4 x float> zeroinitializer ) ; <<4 x float>> [#uses=1] + %tmp = tail call int %llvm.x86.sse.cvttss2si( <4 x float> %tmp59 ) ; <int> [#uses=1] + %tmp69 = cast int %tmp to ushort ; <ushort> [#uses=1] + ret ushort %tmp69 +} + +declare <4 x float> %llvm.x86.sse.sub.ss(<4 x float>, <4 x float>) + +declare <4 x float> %llvm.x86.sse.mul.ss(<4 x float>, <4 x float>) + +declare <4 x float> %llvm.x86.sse.min.ss(<4 x float>, <4 x float>) + +declare <4 x float> %llvm.x86.sse.max.ss(<4 x float>, <4 x float>) + +declare int %llvm.x86.sse.cvttss2si(<4 x float>) diff --git a/llvm/test/Transforms/InstCombine/vec_insert_to_shuffle.ll b/llvm/test/Transforms/InstCombine/vec_insert_to_shuffle.ll new file mode 100644 index 00000000000..0611305beea --- /dev/null +++ b/llvm/test/Transforms/InstCombine/vec_insert_to_shuffle.ll @@ -0,0 +1,14 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep shufflevec | wc -l | grep 1 && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep insertelement && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep extractelement + +<4 x float> %test(<4 x float> %tmp, <4 x float> %tmp1) { + %tmp4 = extractelement <4 x float> %tmp, uint 1 ; <float> [#uses=1] + %tmp2 = extractelement <4 x float> %tmp, uint 3 ; <float> [#uses=1] + %tmp1 = extractelement <4 x float> %tmp1, uint 0 ; <float> [#uses=1] + %tmp128 = insertelement <4 x float> undef, float %tmp4, uint 0 ; <<4 x float>> [#uses=1] + %tmp130 = insertelement <4 x float> %tmp128, float undef, uint 1 ; <<4 x float>> [#uses=1] + %tmp132 = insertelement <4 x float> %tmp130, float %tmp2, uint 2 ; <<4 x float>> [#uses=1] + %tmp134 = insertelement <4 x float> %tmp132, float %tmp1, uint 3 ; <<4 x float>> [#uses=1] + ret <4 x float> %tmp134 +} diff --git a/llvm/test/Transforms/InstCombine/vec_narrow.ll b/llvm/test/Transforms/InstCombine/vec_narrow.ll new file mode 100644 index 00000000000..1ad671c5091 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/vec_narrow.ll @@ -0,0 +1,11 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | grep 'add float' + +%V = type <4 x float> + +float %test(%V %A, %V %B, float %f) { + %C = insertelement %V %A, float %f, uint 0 + %D = add %V %C, %B + %E = extractelement %V %D, uint 0 + ret float %E +} + diff --git a/llvm/test/Transforms/InstCombine/vec_shuffle.ll b/llvm/test/Transforms/InstCombine/vec_shuffle.ll new file mode 100644 index 00000000000..e90d3bef619 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/vec_shuffle.ll @@ -0,0 +1,48 @@ +; RUN: llvm-as < %s | opt -instcombine -disable-output && +; RUN: llvm-as < %s | opt -instcombine | llvm-dis | not grep vector_shuffle + +%T = type <4 x float> + +implementation + +define %T %test1(%T %v1) { + %v2 = shufflevector %T %v1, %T undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3> + ret %T %v2 +} + +define %T %test2(%T %v1) { + %v2 = shufflevector %T %v1, %T %v1, <4 x i32> <i32 0, i32 5, i32 2, i32 7> + ret %T %v2 +} + +define float %test3(%T %A, %T %B, float %f) { + %C = insertelement %T %A, float %f, i32 0 + %D = shufflevector %T %C, %T %B, <4 x i32> <i32 5, i32 0, i32 2, i32 7> + %E = extractelement %T %D, i32 1 + ret float %E +} + +define i32 %test4(<4 x i32> %X) { + %tmp152.i53899.i = shufflevector <4 x i32> %X, <4 x i32> undef, <4 x i32> zeroinitializer + %tmp34 = extractelement <4 x i32> %tmp152.i53899.i, i32 0 + ret i32 %tmp34 +} + +define i32 %test5(<4 x i32> %X) { + %tmp152.i53899.i = shufflevector <4 x i32> %X, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 undef, i32 undef> + %tmp34 = extractelement <4 x i32> %tmp152.i53899.i, i32 0 + ret i32 %tmp34 +} + +define float %test6(<4 x float> %X) { + %X = bitcast <4 x float> %X to <4 x i32> + %tmp152.i53899.i = shufflevector <4 x i32> %X, <4 x i32> undef, <4 x i32> zeroinitializer + %tmp152.i53900.i = bitcast <4 x i32> %tmp152.i53899.i to <4 x float> + %tmp34 = extractelement <4 x float> %tmp152.i53900.i, i32 0 + ret float %tmp34 +} + +define <4 x float> %test7(<4 x float> %tmp45.i) { + %tmp1642.i = shufflevector <4 x float> %tmp45.i, <4 x float> undef, <4 x i32> < i32 0, i32 1, i32 6, i32 7 > + ret <4 x float> %tmp1642.i +} diff --git a/llvm/test/Transforms/InstCombine/xor.ll b/llvm/test/Transforms/InstCombine/xor.ll new file mode 100644 index 00000000000..f87e53a9227 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/xor.ll @@ -0,0 +1,192 @@ +; This test makes sure that these instructions are properly eliminated. +; + +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | not grep 'xor ' + +%G1 = global uint 0 +%G2 = global uint 0 + +implementation + +bool %test0(bool %A) { + %B = xor bool %A, false + ret bool %B +} + +int %test1(int %A) { + %B = xor int %A, 0 + ret int %B +} + +bool %test2(bool %A) { + %B = xor bool %A, %A + ret bool %B +} + +int %test3(int %A) { + %B = xor int %A, %A + ret int %B +} + +int %test4(int %A) { ; A ^ ~A == -1 + %NotA = xor int -1, %A + %B = xor int %A, %NotA + ret int %B +} + +uint %test5(uint %A) { ; (A|B)^B == A & (~B) + %t1 = or uint %A, 123 + %r = xor uint %t1, 123 + ret uint %r +} + +ubyte %test6(ubyte %A) { + %B = xor ubyte %A, 17 + %C = xor ubyte %B, 17 + ret ubyte %C +} + +; (A & C1)^(B & C2) -> (A & C1)|(B & C2) iff C1&C2 == 0 +int %test7(int %A, int %B) { + + %A1 = and int %A, 7 + %B1 = and int %B, 128 + %C1 = xor int %A1, %B1 + ret int %C1 +} + +ubyte %test8(bool %c) { + %d = xor bool %c, true ; invert the condition + br bool %d, label %True, label %False +True: + ret ubyte 1 +False: + ret ubyte 3 +} + +bool %test9(ubyte %A) { + %B = xor ubyte %A, 123 ; xor can be eliminated + %C = seteq ubyte %B, 34 + ret bool %C +} + +ubyte %test10(ubyte %A) { + %B = and ubyte %A, 3 + %C = xor ubyte %B, 4 ; transform into an OR + ret ubyte %C +} + +ubyte %test11(ubyte %A) { + %B = or ubyte %A, 12 + %C = xor ubyte %B, 4 ; transform into an AND + ret ubyte %C +} + +bool %test12(ubyte %A) { + %B = xor ubyte %A, 4 + %c = setne ubyte %B, 0 + ret bool %c +} + +bool %test13(ubyte %A, ubyte %B) { + %C = setlt ubyte %A, %B + %D = setgt ubyte %A, %B + %E = xor bool %C, %D ; E = setne %A, %B + ret bool %E +} + +bool %test14(ubyte %A, ubyte %B) { + %C = seteq ubyte %A, %B + %D = setne ubyte %B, %A + %E = xor bool %C, %D ; E = true + ret bool %E +} + +uint %test15(uint %A) { ; ~(X-1) == -X + %B = add uint %A, 4294967295 + %C = xor uint %B, 4294967295 + ret uint %C +} + +uint %test16(uint %A) { ; ~(X+c) == (-c-1)-X + %B = add uint %A, 123 ; A generalization of the previous case + %C = xor uint %B, 4294967295 + ret uint %C +} + +uint %test17(uint %A) { ; ~(c-X) == X-(c-1) == X+(-c+1) + %B = sub uint 123, %A + %C = xor uint %B, 4294967295 + ret uint %C +} + +uint %test18(uint %A) { ; C - ~X == X + (1+C) + %B = xor uint %A, 4294967295; -~X == 0 - ~X == X+1 + %C = sub uint 123, %B + ret uint %C +} + +uint %test19(uint %A, uint %B) { + %C = xor uint %A, %B + %D = xor uint %C, %A ; A terms cancel, D = B + ret uint %D +} + +void %test20(uint %A, uint %B) { ; The "swap idiom" + %tmp.2 = xor uint %B, %A + %tmp.5 = xor uint %tmp.2, %B + %tmp.8 = xor uint %tmp.5, %tmp.2 + store uint %tmp.8, uint* %G1 ; tmp.8 = B + store uint %tmp.5, uint* %G2 ; tmp.5 = A + ret void +} + +int %test21(bool %C, int %A, int %B) { + %C2 = xor bool %C, true + %D = select bool %C2, int %A, int %B + ret int %D +} + +int %test22(bool %X) { + %Y = xor bool %X, true + %Z = cast bool %Y to int + %Q = xor int %Z, 1 + ret int %Q +} + +bool %test23(int %a, int %b) { + %tmp.2 = xor int %b, %a + %tmp.4 = seteq int %tmp.2, %a + ret bool %tmp.4 +} + +bool %test24(int %c, int %d) { + %tmp.2 = xor int %d, %c + %tmp.4 = setne int %tmp.2, %c + ret bool %tmp.4 +} + +int %test25(int %g, int %h) { + %h2 = xor int %h, -1 + %tmp2 = and int %h2, %g + %tmp4 = xor int %tmp2, %g ; (h2&g)^g -> ~h2 & g -> h & g + ret int %tmp4 +} + +int %test26(int %a, int %b) { + %b2 = xor int %b, -1 + %tmp2 = xor int %a, %b2 + %tmp4 = and int %tmp2, %a ; (a^b2)&a -> ~b2 & a -> b & a + ret int %tmp4 +} + + +i32 %test27(i32 %b, i32 %c, i32 %d) { + %tmp2 = xor i32 %d, %b + %tmp5 = xor i32 %d, %c + %tmp = icmp eq i32 %tmp2, %tmp5 + %tmp6 = zext bool %tmp to i32 + ret i32 %tmp6 +} + diff --git a/llvm/test/Transforms/InstCombine/zeroext-and-reduce.ll b/llvm/test/Transforms/InstCombine/zeroext-and-reduce.ll new file mode 100644 index 00000000000..e171f3aacb0 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/zeroext-and-reduce.ll @@ -0,0 +1,9 @@ +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | \ +; RUN: grep 'and i32 %Y.s, 8' + +int %test1(ubyte %X) { + %Y = cast ubyte %X to int + %Z = and int %Y, 65544 ;; Prune this to and Y, 8 + ret int %Z +} + diff --git a/llvm/test/Transforms/InstCombine/zext.ll b/llvm/test/Transforms/InstCombine/zext.ll new file mode 100644 index 00000000000..7835fe690b2 --- /dev/null +++ b/llvm/test/Transforms/InstCombine/zext.ll @@ -0,0 +1,9 @@ +; Tests to make sure elimination of casts is working correctly +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine -disable-output && +; RUN: llvm-upgrade < %s | llvm-as | opt -instcombine | llvm-dis | notcast '' '%c1.*' + +long %test_sext_zext(short %A) { + %c1 = zext short %A to uint + %c2 = sext uint %c1 to long + ret long %c2 +} |
