test/CodeGen/volatile-1.c

   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
   4 volatile int i, j, k;
   5 volatile int ar[5];
   6 volatile char c;
   7 // CHECK: @ci = common global [[CINT:%.*]] zeroinitializer
   8 volatile _Complex int ci;
   9 volatile 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;
  17 int 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()
  26 void 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
 305 extern volatile enum X x;
 306 // CHECK: define void @test1()
 307 void test1() {
 308   extern void test1_helper(void);
 309   test1_helper();
 310   // CHECK: call void @test1_helper()
 311   // CHECK-NEXT: ret void
 312   x;
 313   (void) x;
 314   return x;
 315 }