clang/test/CodeGen/exprs.c

   1 // RUN: %clang_cc1 -triple x86_64-unknown-unknown %s -Wno-strict-prototypes -emit-llvm -o - | FileCheck %s
   2
   3 // PR1895
   4 // sizeof function
   5 int zxcv(void);
   6 int x=sizeof(zxcv);
   7 int y=__alignof__(zxcv);
   8
   9
  10 void *test(int *i) {
  11  short a = 1;
  12  i += a;
  13  i + a;
  14  a + i;
  15 }
  16
  17 _Bool test2b;
  18 int test2(void) { if (test2b); return 0; }
  19
  20 // PR1921
  21 int test3(void) {
  22   const unsigned char *bp;
  23   bp -= (short)1;
  24 }
  25
  26 // PR2080 - sizeof void
  27 int t1 = sizeof(void);
  28 int t2 = __alignof__(void);
  29 void test4(void) {
  30   t1 = sizeof(void);
  31   t2 = __alignof__(void);
  32
  33   t1 = sizeof(test4());
  34   t2 = __alignof__(test4());
  35 }
  36
  37 // 'const float' promotes to double in varargs.
  38 int test5(const float x, float float_number) {
  39   return __builtin_isless(x, float_number);
  40 }
  41
  42 // this one shouldn't fold
  43 int ola(void) {
  44   int a=2;
  45   if ((0, (int)a) & 2) { return 1; }
  46   return 2;
  47 }
  48
  49 // this one shouldn't fold as well
  50 void eMaisUma(void) {
  51   double t[1];
  52   if (*t)
  53     return;
  54 }
  55
  56 // rdar://6520707
  57 void f0(void (*fp)(void), void (*fp2)(void)) {
  58   int x = fp - fp2;
  59 }
  60
  61 // noop casts as lvalues.
  62 struct X {
  63   int Y;
  64 };
  65 struct X foo();
  66 int bar(void) {
  67   return ((struct X)foo()).Y + 1;
  68 }
  69
  70 // PR3809: INC/DEC of function pointers.
  71 void f2(void);
  72 unsigned f1(void) {
  73   void (*fp)(void) = f2;
  74
  75   ++fp;
  76   fp++;
  77   --fp;
  78   fp--;
  79   return (unsigned) fp;
  80 }
  81
  82 union f3_x {int x; float y;};
  83 int f3(void) {return ((union f3_x)2).x;}
  84
  85 union f4_y {int x; _Complex float y;};
  86 _Complex float f4(void) {return ((union f4_y)(_Complex float)2.0).y;}
  87
  88 struct f5_a { int a; } f5_a;
  89 union f5_z {int x; struct f5_a y;};
  90 struct f5_a f5(void) {return ((union f5_z)f5_a).y;}
  91
  92 // ?: in "lvalue"
  93 struct s6 { int f0; };
  94 int f6(int a0, struct s6 a1, struct s6 a2) {
  95   return (a0 ? a1 : a2).f0;
  96 }
  97
  98 // PR4026
  99 void f7(void) {
 100   __func__;
 101 }
 102
 103 // PR4067
 104 int f8(void) {
 105   return ({ foo(); }).Y;
 106 }
 107
 108 // rdar://6880558
 109 struct S;
 110 struct C {
 111   int i;
 112   struct S *tab[];
 113 };
 114 struct S { struct C c; };
 115 void f9(struct S *x) {
 116   foo(((void)1, x->c).tab[0]);
 117 }
 118
 119 void f10(void) {
 120   __builtin_sin(0);
 121 }
 122
 123 // rdar://7530813
 124 // CHECK-LABEL: define{{.*}} i32 @f11
 125 int f11(long X) {
 126   int A[100];
 127   return A[X];
 128
 129 // CHECK: [[Xaddr:%[^ ]+]] = alloca i64, align 8
 130 // CHECK: [[A:%.*]] = alloca [100 x i32], align
 131 // CHECK: [[X:%.*]] = load {{.*}}, ptr [[Xaddr]]
 132 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [100 x i32], ptr [[A]], i64 0, i64 [[X]]
 133 // CHECK-NEXT: load i32, ptr [[T0]], align 4
 134 }
 135
 136 int f12(void) {
 137   // PR3150
 138   // CHECK-LABEL: define{{.*}} i32 @f12
 139   // CHECK: ret i32 1
 140   return 1||1;
 141 }
 142
 143 // Make sure negate of fp uses -0.0 for proper -0 handling.
 144 double f13(double X) {
 145   // CHECK-LABEL: define{{.*}} double @f13
 146   // CHECK: fneg double
 147   return -X;
 148 }
 149
 150 // Check operations on incomplete types.
 151 void f14(struct s14 *a) {
 152   (void) &*a;
 153 }
 154
 155 // CHECK-LABEL: define{{.*}} void @f15
 156 void f15(void) {
 157   extern void f15_start(void);
 158   f15_start();
 159   // CHECK: call void @f15_start()
 160
 161   extern void *f15_v(void);
 162   extern const void *f15_cv(void);
 163   extern volatile void *f15_vv(void);
 164   *f15_v(); *f15_v(), *f15_v(); f15_v() ? *f15_v() : *f15_v();
 165   *f15_cv(); *f15_cv(), *f15_cv(); f15_cv() ? *f15_cv() : *f15_cv();
 166   *f15_vv(); *f15_vv(), *f15_vv(); f15_vv() ? *f15_vv() : *f15_vv();
 167   // CHECK-NOT: load
 168   // CHECK: ret void
 169 }
 170
 171 // PR8967: this was crashing
 172 // CHECK-LABEL: define{{.*}} void @f16()
 173 void f16(void) {
 174   __extension__({ goto lbl; });
 175  lbl:
 176   ;
 177 }
 178
 179 // PR13704: negative increment in i128 is not preserved.
 180 // CHECK-LABEL: define{{.*}} void @f17()
 181 void f17(void) {
 182   extern void extfunc(__int128);
 183   __int128 x = 2;
 184   x--;
 185   extfunc(x);
 186 // CHECK: add nsw i128 %{{.}}, -1
 187 }
 188
 189 // PR23597: We should evaluate union cast operands even if the cast is unused.
 190 typedef union u {
 191     int i;
 192 } strct;
 193 int returns_int(void);
 194 void f18(void) {
 195   (strct)returns_int();
 196 }
 197 // CHECK-LABEL: define{{.*}} void @f18()
 198 // CHECK: call i32 @returns_int()
 199
 200 // Ensure the right stmt is returned
 201 int f19(void) {
 202   return ({ 3;;4;; });
 203 }
 204 // CHECK-LABEL: define{{.*}} i32 @f19()
 205 // CHECK: [[T:%.*]] = alloca i32
 206 // CHECK: store i32 4, ptr [[T]]
 207 // CHECK: [[L:%.*]] = load i32, ptr [[T]]
 208 // CHECK: ret i32 [[L]]