volatile-1.c revision f6a1648197562e0b133440d612d9af297d0a86cc 
1// RUN: %clang_cc1 -Wno-return-type -Wno-unused-value -emit-llvm %s -o - | FileCheck %s
2
3// CHECK: @i = common global [[INT:i[0-9]+]] 0
4volatile int i, j, k;
5volatile int ar[5];
6volatile char c;
7// CHECK: @ci = common global [[CINT:%.*]] zeroinitializer
8volatile _Complex int ci;
9volatile struct S {
10#ifdef __cplusplus
11  void operator =(volatile struct S&o) volatile;
12#endif
13  int i;
14} a, b;
15
16//void operator =(volatile struct S&o1, volatile struct S&o2) volatile;
17int printf(const char *, ...);
18
19
20// Note that these test results are very much specific to C!
21// Assignments in C++ yield l-values, not r-values, and the situations
22// that do implicit lvalue-to-rvalue conversion are substantially
23// reduced.
24
25// CHECK: define void @test()
26void test() {
27  // CHECK: volatile load [[INT]]* @i
28  i;
29  // CHECK-NEXT: volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
30  // CHECK-NEXT: volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
31  // CHECK-NEXT: sitofp [[INT]]
32  (float)(ci);
33  // CHECK-NEXT: volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
34  // CHECK-NEXT: volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
35  (void)ci;
36  // CHECK-NEXT: bitcast
37  // CHECK-NEXT: memcpy
38  (void)a;
39  // CHECK-NEXT: [[R:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
40  // CHECK-NEXT: [[I:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
41  // CHECK-NEXT: volatile store [[INT]] [[R]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
42  // CHECK-NEXT: volatile store [[INT]] [[I]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
43  (void)(ci=ci);
44  // CHECK-NEXT: [[T:%.*]] = volatile load [[INT]]* @j
45  // CHECK-NEXT: volatile store [[INT]] [[T]], [[INT]]* @i
46  (void)(i=j);
47  // CHECK-NEXT: [[R1:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
48  // CHECK-NEXT: [[I1:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
49  // CHECK-NEXT: [[R2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
50  // CHECK-NEXT: [[I2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
51  // Not sure why they're ordered this way.
52  // CHECK-NEXT: [[R:%.*]] = add [[INT]] [[R2]], [[R1]]
53  // CHECK-NEXT: [[I:%.*]] = add [[INT]] [[I2]], [[I1]]
54  // CHECK-NEXT: volatile store [[INT]] [[R]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
55  // CHECK-NEXT: volatile store [[INT]] [[I]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
56  ci+=ci;
57
58  // CHECK-NEXT: [[R1:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
59  // CHECK-NEXT: [[I1:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
60  // CHECK-NEXT: [[R2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
61  // CHECK-NEXT: [[I2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
62  // CHECK-NEXT: [[R:%.*]] = add [[INT]] [[R2]], [[R1]]
63  // CHECK-NEXT: [[I:%.*]] = add [[INT]] [[I2]], [[I1]]
64  // CHECK-NEXT: volatile store [[INT]] [[R]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
65  // CHECK-NEXT: volatile store [[INT]] [[I]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
66  // CHECK-NEXT: [[R2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 0)
67  // CHECK-NEXT: [[I2:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
68  // These additions can be elided
69  // CHECK-NEXT: add [[INT]] [[R]], [[R2]]
70  // CHECK-NEXT: add [[INT]] [[I]], [[I2]]
71  (ci += ci) + ci;
72  // CHECK-NEXT: call void asm
73  asm("nop");
74  // CHECK-NEXT: volatile load
75  // CHECK-NEXT: volatile load
76  // CHECK-NEXT: add nsw [[INT]]
77  // CHECK-NEXT: volatile store
78  // CHECK-NEXT: volatile load
79  // CHECK-NEXT: add nsw [[INT]]
80  (i += j) + k;
81  // CHECK-NEXT: call void asm
82  asm("nop");
83  // CHECK-NEXT: volatile load
84  // CHECK-NEXT: volatile load
85  // CHECK-NEXT: add nsw [[INT]]
86  // CHECK-NEXT: volatile store
87  // CHECK-NEXT: add nsw [[INT]]
88  (i += j) + 1;
89  // CHECK-NEXT: call void asm
90  asm("nop");
91  // CHECK-NEXT: volatile load
92  // CHECK-NEXT: volatile load
93  // CHECK-NEXT: volatile load
94  // CHECK-NEXT: volatile load
95  // CHECK-NEXT: add [[INT]]
96  // CHECK-NEXT: add [[INT]]
97  ci+ci;
98
99  // CHECK-NEXT: volatile load
100  __real i;
101  // CHECK-NEXT: volatile load
102  // CHECK-NEXT: volatile load
103  +ci;
104  // CHECK-NEXT: call void asm
105  asm("nop");
106  // CHECK-NEXT: volatile load
107  // CHECK-NEXT: volatile store
108  (void)(i=i);
109  // CHECK-NEXT: volatile load
110  // CHECK-NEXT: volatile store
111  // CHECK-NEXT: sitofp
112  (float)(i=i);
113  // CHECK-NEXT: volatile load
114  (void)i;
115  // CHECK-NEXT: volatile load
116  // CHECK-NEXT: volatile store
117  i=i;
118  // CHECK-NEXT: volatile load
119  // CHECK-NEXT: volatile store
120  // CHECK-NEXT: volatile store
121  i=i=i;
122#ifndef __cplusplus
123  // CHECK-NEXT: volatile load
124  // CHECK-NEXT: volatile store
125  (void)__builtin_choose_expr(0, i=i, j=j);
126#endif
127  // CHECK-NEXT: volatile load
128  // CHECK-NEXT: icmp
129  // CHECK-NEXT: br i1
130  // CHECK: volatile load
131  // CHECK-NEXT: volatile store
132  // CHECK-NEXT: br label
133  // CHECK: volatile load
134  // CHECK-NEXT: volatile store
135  // CHECK-NEXT: br label
136  k ? (i=i) : (j=j);
137  // CHECK: phi
138  // CHECK-NEXT: volatile load
139  // CHECK-NEXT: volatile load
140  // CHECK-NEXT: volatile store
141  (void)(i,(i=i));
142  // CHECK-NEXT: volatile load
143  // CHECK-NEXT: volatile store
144  // CHECK-NEXT: volatile load
145  i=i,i;
146  // CHECK-NEXT: volatile load
147  // CHECK-NEXT: volatile store
148  // CHECK-NEXT: volatile load
149  // CHECK-NEXT: volatile store
150  (i=j,k=j);
151  // CHECK-NEXT: volatile load
152  // CHECK-NEXT: volatile store
153  // CHECK-NEXT: volatile load
154  (i=j,k);
155  // CHECK-NEXT: volatile load
156  // CHECK-NEXT: volatile load
157  (i,j);
158  // CHECK-NEXT: volatile load
159  // CHECK-NEXT: trunc
160  // CHECK-NEXT: volatile store
161  // CHECK-NEXT: sext
162  // CHECK-NEXT: volatile store
163  i=c=k;
164  // CHECK-NEXT: volatile load
165  // CHECK-NEXT: volatile load
166  // CHECK-NEXT: add nsw [[INT]]
167  // CHECK-NEXT: volatile store
168  i+=k;
169  // CHECK-NEXT: volatile load
170  // CHECK-NEXT: volatile load
171  ci;
172#ifndef __cplusplus
173  // CHECK-NEXT: volatile load
174  // CHECK-NEXT: volatile load
175  (int)ci;
176  // CHECK-NEXT: volatile load
177  // CHECK-NEXT: volatile load
178  // CHECK-NEXT: icmp ne
179  // CHECK-NEXT: icmp ne
180  // CHECK-NEXT: or i1
181  (_Bool)ci;
182#endif
183  // CHECK-NEXT: volatile load
184  // CHECK-NEXT: volatile load
185  // CHECK-NEXT: volatile store
186  // CHECK-NEXT: volatile store
187  ci=ci;
188  // CHECK-NEXT: volatile load
189  // CHECK-NEXT: volatile load
190  // CHECK-NEXT: volatile store
191  // CHECK-NEXT: volatile store
192  // CHECK-NEXT: volatile store
193  // CHECK-NEXT: volatile store
194  ci=ci=ci;
195  // CHECK-NEXT: [[T:%.*]] = volatile load [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
196  // CHECK-NEXT: volatile store [[INT]] [[T]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
197  // CHECK-NEXT: volatile store [[INT]] [[T]], [[INT]]* getelementptr inbounds ([[CINT]]* @ci, i32 0, i32 1)
198  __imag ci = __imag ci = __imag ci;
199  // CHECK-NEXT: volatile load
200  // CHECK-NEXT: volatile store
201  __real (i = j);
202  // CHECK-NEXT: volatile load
203  __imag i;
204
205  // ============================================================
206  // FIXME: Test cases we get wrong.
207
208  // A use.  We load all of a into a copy of a, then load i.  gcc forgets to do
209  // the assignment.
210  // (a = a).i;
211
212  // ============================================================
213  // Test cases where we intentionally differ from gcc, due to suspected bugs in
214  // gcc.
215
216  // Not a use.  gcc forgets to do the assignment.
217  // CHECK-NEXT: call void @llvm.memcpy{{.*}}, i1 true
218  // CHECK-NEXT: bitcast
219  // CHECK-NEXT: call void @llvm.memcpy{{.*}}, i1 true
220  ((a=a),a);
221
222  // Not a use.  gcc gets this wrong, it doesn't emit the copy!
223  // (void)(a=a);
224
225  // Not a use.  gcc got this wrong in 4.2 and omitted the side effects
226  // entirely, but it is fixed in 4.4.0.
227  // CHECK-NEXT: volatile load
228  // CHECK-NEXT: volatile store
229  __imag (i = j);
230
231#ifndef __cplusplus
232  // A use of the real part
233  // CHECK-NEXT: volatile load
234  // CHECK-NEXT: volatile load
235  // CHECK-NEXT: volatile store
236  // CHECK-NEXT: volatile store
237  // CHECK-NEXT: sitofp
238  (float)(ci=ci);
239  // Not a use, bug?  gcc treats this as not a use, that's probably a bug due to
240  // tree folding ignoring volatile.
241  // CHECK-NEXT: volatile load
242  // CHECK-NEXT: volatile load
243  // CHECK-NEXT: volatile store
244  // CHECK-NEXT: volatile store
245  (int)(ci=ci);
246#endif
247
248  // A use.
249  // CHECK-NEXT: volatile load
250  // CHECK-NEXT: volatile store
251  // CHECK-NEXT: sitofp
252  (float)(i=i);
253  // A use.  gcc treats this as not a use, that's probably a bug due to tree
254  // folding ignoring volatile.
255  // CHECK-NEXT: volatile load
256  // CHECK-NEXT: volatile store
257  (int)(i=i);
258
259  // A use.
260  // CHECK-NEXT: volatile load
261  // CHECK-NEXT: volatile store
262  // CHECK-NEXT: sub
263  -(i=j);
264  // A use.  gcc treats this a not a use, that's probably a bug due to tree
265  // folding ignoring volatile.
266  // CHECK-NEXT: volatile load
267  // CHECK-NEXT: volatile store
268  +(i=k);
269
270  // A use. gcc treats this a not a use, that's probably a bug due to tree
271  // folding ignoring volatile.
272  // CHECK-NEXT: volatile load
273  // CHECK-NEXT: volatile load
274  // CHECK-NEXT: volatile store
275  // CHECK-NEXT: volatile store
276  __real (ci=ci);
277
278  // A use.
279  // CHECK-NEXT: volatile load
280  // CHECK-NEXT: add
281  i + 0;
282  // A use.
283  // CHECK-NEXT: volatile load
284  // CHECK-NEXT: volatile store
285  // CHECK-NEXT: volatile load
286  // CHECK-NEXT: add
287  (i=j) + i;
288  // A use.  gcc treats this as not a use, that's probably a bug due to tree
289  // folding ignoring volatile.
290  // CHECK-NEXT: volatile load
291  // CHECK-NEXT: volatile store
292  // CHECK-NEXT: add
293  (i=j) + 0;
294
295#ifdef __cplusplus
296  (i,j)=k;
297  (j=k,i)=i;
298  struct { int x; } s, s1;
299  printf("s is at %p\n", &s);
300  printf("s is at %p\n", &(s = s1));
301  printf("s.x is at %p\n", &((s = s1).x));
302#endif
303}
304
305extern volatile enum X x;
306// CHECK: define void @test1()
307void test1() {
308  // CHECK-NEXT: :
309  // CHECK-NEXT: ret void
310  x;
311  (void) x;
312  return x;
313}
314