| OLD | NEW |
| (Empty) | |
| 1 ; This tests the advanced lowering of switch statements. The advanced lowering |
| 2 ; uses jump tables, range tests and binary search. |
| 3 |
| 4 ; RUN: %p2i -i %s --filetype=asm --assemble --disassemble --args --adv-switch \ |
| 5 ; RUN: -O2 | FileCheck %s |
| 6 |
| 7 ; Dense but non-continuous ranges should be converted into a jump table. |
| 8 define internal i32 @testJumpTable(i32 %a) { |
| 9 entry: |
| 10 switch i32 %a, label %sw.default [ |
| 11 i32 91, label %sw.default |
| 12 i32 92, label %sw.bb1 |
| 13 i32 93, label %sw.default |
| 14 i32 99, label %sw.bb1 |
| 15 i32 98, label %sw.default |
| 16 i32 96, label %sw.bb1 |
| 17 i32 97, label %sw.epilog |
| 18 ] |
| 19 |
| 20 sw.default: |
| 21 %add = add i32 %a, 27 |
| 22 br label %sw.epilog |
| 23 |
| 24 sw.bb1: |
| 25 %tmp = add i32 %a, 16 |
| 26 br label %sw.epilog |
| 27 |
| 28 sw.epilog: |
| 29 %result.1 = phi i32 [ %add, %sw.default ], [ %tmp, %sw.bb1 ], [ 17, %entry ] |
| 30 ret i32 %result.1 |
| 31 } |
| 32 ; CHECK-LABEL: testJumpTable |
| 33 ; CHECK: sub [[IND:[^,]+]],0x5b |
| 34 ; CHECK-NEXT: cmp [[IND]],0x8 |
| 35 ; CHECK-NEXT: ja |
| 36 ; CHECK-NEXT: mov [[BASE:[^,]+]],0x0 {{[0-9a-f]+}}: R_386_32 .rodata.testJumpTab
le$jumptable |
| 37 ; CHECK-NEXT: mov {{.*}},DWORD PTR {{\[}}[[BASE]]+[[IND]]*4] |
| 38 ; CHECK-NEXT: jmp |
| 39 |
| 40 ; Continuous ranges which map to the same target should be grouped and |
| 41 ; efficiently tested. |
| 42 define internal i32 @testRangeTest() { |
| 43 entry: |
| 44 switch i32 10, label %sw.default [ |
| 45 i32 0, label %sw.epilog |
| 46 i32 1, label %sw.epilog |
| 47 i32 2, label %sw.epilog |
| 48 i32 3, label %sw.epilog |
| 49 i32 10, label %sw.bb1 |
| 50 i32 11, label %sw.bb1 |
| 51 i32 12, label %sw.bb1 |
| 52 i32 13, label %sw.bb1 |
| 53 ] |
| 54 |
| 55 sw.default: |
| 56 br label %sw.epilog |
| 57 |
| 58 sw.bb1: |
| 59 br label %sw.epilog |
| 60 |
| 61 sw.epilog: |
| 62 %result.1 = phi i32 [ 23, %sw.default ], [ 42, %sw.bb1 ], [ 17, %entry ], [ 17
, %entry ], [ 17, %entry ], [ 17, %entry ] |
| 63 ret i32 %result.1 |
| 64 } |
| 65 ; CHECK-LABEL: testRangeTest |
| 66 ; CHECK: cmp {{.*}},0x3 |
| 67 ; CHECK-NEXT: jbe |
| 68 ; CHECK: sub [[REG:[^,]*]],0xa |
| 69 ; CHECK-NEXT: cmp [[REG]],0x3 |
| 70 ; CHECK-NEXT: jbe |
| 71 ; CHECK-NEXT: jmp |
| 72 |
| 73 ; Sparse cases should be searched with a binary search. |
| 74 define internal i32 @testBinarySearch() { |
| 75 entry: |
| 76 switch i32 10, label %sw.default [ |
| 77 i32 0, label %sw.epilog |
| 78 i32 10, label %sw.epilog |
| 79 i32 20, label %sw.bb1 |
| 80 i32 30, label %sw.bb1 |
| 81 ] |
| 82 |
| 83 sw.default: |
| 84 br label %sw.epilog |
| 85 |
| 86 sw.bb1: |
| 87 br label %sw.epilog |
| 88 |
| 89 sw.epilog: |
| 90 %result.1 = phi i32 [ 23, %sw.default ], [ 42, %sw.bb1 ], [ 17, %entry ], [ 17
, %entry ] |
| 91 ret i32 %result.1 |
| 92 } |
| 93 ; CHECK-LABEL: testBinarySearch |
| 94 ; CHECK: cmp {{.*}},0x14 |
| 95 ; CHECK-NEXT: jb |
| 96 ; CHECK-NEXT: je |
| 97 ; CHECK-NEXT: cmp {{.*}},0x1e |
| 98 ; CHECK-NEXT: je |
| 99 ; CHECK-NEXT: jmp |
| 100 ; CHECK-NEXT: cmp {{.*}},0x0 |
| 101 ; CHECK-NEXT: je |
| 102 ; CHECK-NEXT: cmp {{.*}},0xa |
| 103 ; CHECK-NEXT: je |
| 104 ; CHECK-NEXT: jmp |
| 105 |
| 106 ; 64-bit switches where the cases are all 32-bit values should be reduced to a |
| 107 ; 32-bit switch after checking the top byte is 0. |
| 108 define internal i32 @testSwitchSmall64(i64 %a) { |
| 109 entry: |
| 110 switch i64 %a, label %sw.default [ |
| 111 i64 123, label %return |
| 112 i64 234, label %sw.bb1 |
| 113 i64 345, label %sw.bb2 |
| 114 i64 456, label %sw.bb3 |
| 115 ] |
| 116 |
| 117 sw.bb1: |
| 118 br label %return |
| 119 |
| 120 sw.bb2: |
| 121 br label %return |
| 122 |
| 123 sw.bb3: |
| 124 br label %return |
| 125 |
| 126 sw.default: |
| 127 br label %return |
| 128 |
| 129 return: |
| 130 %retval.0 = phi i32 [ 5, %sw.default ], [ 4, %sw.bb3 ], [ 3, %sw.bb2 ], [ 2, %
sw.bb1 ], [ 1, %entry ] |
| 131 ret i32 %retval.0 |
| 132 } |
| 133 ; CHECK-LABEL: testSwitchSmall64 |
| 134 ; CHECK: cmp {{.*}},0x0 |
| 135 ; CHECK-NEXT: jne |
| 136 ; CHECK-NEXT: cmp {{.*}},0x159 |
| 137 ; CHECK-NEXT: jb |
| 138 ; CHECK-NEXT: je |
| 139 ; CHECK-NEXT: cmp {{.*}},0x1c8 |
| 140 ; CHECK-NEXT: je |
| 141 ; CHECK-NEXT: jmp |
| 142 ; CHECK-NEXT: cmp {{.*}},0x7b |
| 143 ; CHECK-NEXT: je |
| 144 ; CHECK-NEXT: cmp {{.*}},0xea |
| 145 ; CHECK-NEXT: je |
| 146 ; CHECK-NEXT: jmp |
| 147 |
| 148 ; Test for correct 64-bit lowering. |
| 149 ; TODO(ascull): this should generate better code like the 32-bit version |
| 150 define internal i32 @testSwitch64(i64 %a) { |
| 151 entry: |
| 152 switch i64 %a, label %sw.default [ |
| 153 i64 123, label %return |
| 154 i64 234, label %sw.bb1 |
| 155 i64 345, label %sw.bb2 |
| 156 i64 78187493520, label %sw.bb3 |
| 157 ] |
| 158 |
| 159 sw.bb1: |
| 160 br label %return |
| 161 |
| 162 sw.bb2: |
| 163 br label %return |
| 164 |
| 165 sw.bb3: |
| 166 br label %return |
| 167 |
| 168 sw.default: |
| 169 br label %return |
| 170 |
| 171 return: |
| 172 %retval.0 = phi i32 [ 5, %sw.default ], [ 4, %sw.bb3 ], [ 3, %sw.bb2 ], [ 2, %
sw.bb1 ], [ 1, %entry ] |
| 173 ret i32 %retval.0 |
| 174 } |
| 175 ; CHECK-LABEL: testSwitch64 |
| 176 ; CHECK: cmp {{.*}},0x7b |
| 177 ; CHECK-NEXT: jne |
| 178 ; CHECK-NEXT: cmp {{.*}},0x0 |
| 179 ; CHECK-NEXT: je |
| 180 ; CHECK: cmp {{.*}},0xea |
| 181 ; CHECK-NEXT: jne |
| 182 ; CHECK-NEXT: cmp {{.*}},0x0 |
| 183 ; CHECK-NEXT: je |
| 184 ; CHECK: cmp {{.*}},0x159 |
| 185 ; CHECK-NEXT: jne |
| 186 ; CHECK-NEXT: cmp {{.*}},0x0 |
| 187 ; CHECK-NEXT: je |
| 188 ; CHECK: cmp {{.*}},0x34567890 |
| 189 ; CHECK-NEXT: jne |
| 190 ; CHECK-NEXT: cmp {{.*}},0x12 |
| 191 ; CHECK-NEXT: je |
| OLD | NEW |