Mercurial > hg > CbC > CbC_llvm

comparison clang/test/CodeGen/switch.c @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 2e18cbf3894f
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
1 // RUN: %clang_cc1 -triple i386-unknown-unknown -O3 %s -emit-llvm -o - | FileCheck %s
2
3 int foo(int i) {
4 int j = 0;
5 switch (i) {
6 case -1:
7 j = 1; break;
8 case 1 :
9 j = 2; break;
10 case 2:
11 j = 3; break;
12 default:
13 j = 42; break;
14 }
15 j = j + 1;
16 return j;
17 }
18
19 int foo2(int i) {
20 int j = 0;
21 switch (i) {
22 case 1 :
23 j = 2; break;
24 case 2 ... 10:
25 j = 3; break;
26 default:
27 j = 42; break;
28 }
29 j = j + 1;
30 return j;
31 }
32
33 int foo3(int i) {
34 int j = 0;
35 switch (i) {
36 default:
37 j = 42; break;
38 case 111:
39 j = 111; break;
40 case 0 ... 100:
41 j = 1; break;
42 case 222:
43 j = 222; break;
44 }
45 return j;
46 }
47
48
49 static int foo4(int i) {
50 int j = 0;
51 switch (i) {
52 case 111:
53 j = 111; break;
54 case 0 ... 100:
55 j = 1; break;
56 case 222:
57 j = 222; break;
58 default:
59 j = 42; break;
60 case 501 ... 600:
61 j = 5; break;
62 }
63 return j;
64 }
65
66 // CHECK-LABEL: define i32 @foo4t()
67 // CHECK: ret i32 376
68 // CHECK: }
69 int foo4t() {
70 // 111 + 1 + 222 + 42 = 376
71 return foo4(111) + foo4(99) + foo4(222) + foo4(601);
72 }
73
74 // CHECK-LABEL: define void @foo5()
75 // CHECK-NOT: switch
76 // CHECK: }
77 void foo5(){
78 switch(0){
79 default:
80 if (0) {
81
82 }
83 }
84 }
85
86 // CHECK-LABEL: define void @foo6()
87 // CHECK-NOT: switch
88 // CHECK: }
89 void foo6(){
90 switch(0){
91 }
92 }
93
94 // CHECK-LABEL: define void @foo7()
95 // CHECK-NOT: switch
96 // CHECK: }
97 void foo7(){
98 switch(0){
99 foo7();
100 }
101 }
102
103
104 // CHECK-LABEL: define i32 @f8(
105 // CHECK: ret i32 3
106 // CHECK: }
107 int f8(unsigned x) {
108 switch(x) {
109 default:
110 return 3;
111 case 0xFFFFFFFF ... 1: // This range should be empty because x is unsigned.
112 return 0;
113 }
114 }
115
116 // Ensure that default after a case range is not ignored.
117 //
118 // CHECK-LABEL: define i32 @f9()
119 // CHECK: ret i32 10
120 // CHECK: }
121 static int f9_0(unsigned x) {
122 switch(x) {
123 case 10 ... 0xFFFFFFFF:
124 return 0;
125 default:
126 return 10;
127 }
128 }
129 int f9() {
130 return f9_0(2);
131 }
132
133 // Ensure that this doesn't compile to infinite loop in g() due to
134 // miscompilation of fallthrough from default to a (tested) case
135 // range.
136 //
137 // CHECK-LABEL: define i32 @f10()
138 // CHECK: ret i32 10
139 // CHECK: }
140 static int f10_0(unsigned x) {
141 switch(x) {
142 default:
143 x += 1;
144 case 10 ... 0xFFFFFFFF:
145 return 0;
146 }
147 }
148
149 int f10() {
150 f10_0(1);
151 return 10;
152 }
153
154 // This generated incorrect code because of poor switch chaining.
155 //
156 // CHECK-LABEL: define i32 @f11(
157 // CHECK: ret i32 3
158 // CHECK: }
159 int f11(int x) {
160 switch(x) {
161 default:
162 return 3;
163 case 10 ... 0xFFFFFFFF:
164 return 0;
165 }
166 }
167
168 // This just asserted because of the way case ranges were calculated.
169 //
170 // CHECK-LABEL: define i32 @f12(
171 // CHECK: ret i32 3
172 // CHECK: }
173 int f12(int x) {
174 switch (x) {
175 default:
176 return 3;
177 case 10 ... -1:
178 return 0;
179 }
180 }
181
182 // Make sure return is not constant (if empty range is skipped or miscompiled)
183 //
184 // CHECK-LABEL: define i32 @f13(
185 // CHECK: ret i32 %
186 // CHECK: }
187 int f13(unsigned x) {
188 switch(x) {
189 case 2:
190 // fallthrough empty range
191 case 10 ... 9:
192 return 10;
193 default:
194 return 0;
195 }
196 }
197
198 // Don't delete a basic block that we want to introduce later references to.
199 // This isn't really specific to switches, but it's easy to show with them.
200 // rdar://problem/8837067
201 int f14(int x) {
202 switch (x) {
203
204 // case range so that the case block has no predecessors
205 case 0 ... 15:
206 // any expression which doesn't introduce a new block
207 (void) 0;
208 // kaboom
209
210 default:
211 return x;
212 }
213 }