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 void f0(void (*fp)(void), void (*fp2)(void)) {
  57   int x = fp - fp2;
  58 }
  59
  60 // noop casts as lvalues.
  61 struct X {
  62   int Y;
  63 };
  64 struct X foo();
  65 int bar(void) {
  66   return ((struct X)foo()).Y + 1;
  67 }
  68
  69 // PR3809: INC/DEC of function pointers.
  70 void f2(void);
  71 unsigned f1(void) {
  72   void (*fp)(void) = f2;
  73
  74   ++fp;
  75   fp++;
  76   --fp;
  77   fp--;
  78   return (unsigned) fp;
  79 }
  80
  81 union f3_x {int x; float y;};
  82 int f3(void) {return ((union f3_x)2).x;}
  83
  84 union f4_y {int x; _Complex float y;};
  85 _Complex float f4(void) {return ((union f4_y)(_Complex float)2.0).y;}
  86
  87 struct f5_a { int a; } f5_a;
  88 union f5_z {int x; struct f5_a y;};
  89 struct f5_a f5(void) {return ((union f5_z)f5_a).y;}
  90
  91 // ?: in "lvalue"
  92 struct s6 { int f0; };
  93 int f6(int a0, struct s6 a1, struct s6 a2) {
  94   return (a0 ? a1 : a2).f0;
  95 }
  96
  97 // PR4026
  98 void f7(void) {
  99   __func__;
 100 }
 101
 102 // PR4067
 103 int f8(void) {
 104   return ({ foo(); }).Y;
 105 }
 106
 107 struct S;
 108 struct C {
 109   int i;
 110   struct S *tab[];
 111 };
 112 struct S { struct C c; };
 113 void f9(struct S *x) {
 114   foo(((void)1, x->c).tab[0]);
 115 }
 116
 117 void f10(void) {
 118   __builtin_sin(0);
 119 }
 120
 121 // CHECK-LABEL: define{{.*}} i32 @f11
 122 int f11(long X) {
 123   int A[100];
 124   return A[X];
 125
 126 // CHECK: [[Xaddr:%[^ ]+]] = alloca i64, align 8
 127 // CHECK: [[A:%.*]] = alloca [100 x i32], align
 128 // CHECK: [[X:%.*]] = load {{.*}}, ptr [[Xaddr]]
 129 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [100 x i32], ptr [[A]], i64 0, i64 [[X]]
 130 // CHECK-NEXT: load i32, ptr [[T0]], align 4
 131 }
 132
 133 int f12(void) {
 134   // PR3150
 135   // CHECK-LABEL: define{{.*}} i32 @f12
 136   // CHECK: ret i32 1
 137   return 1||1;
 138 }
 139
 140 // Make sure negate of fp uses -0.0 for proper -0 handling.
 141 double f13(double X) {
 142   // CHECK-LABEL: define{{.*}} double @f13
 143   // CHECK: fneg double
 144   return -X;
 145 }
 146
 147 // Check operations on incomplete types.
 148 void f14(struct s14 *a) {
 149   (void) &*a;
 150 }
 151
 152 // CHECK-LABEL: define{{.*}} void @f15
 153 void f15(void) {
 154   extern void f15_start(void);
 155   f15_start();
 156   // CHECK: call void @f15_start()
 157
 158   extern void *f15_v(void);
 159   extern const void *f15_cv(void);
 160   extern volatile void *f15_vv(void);
 161   *f15_v(); *f15_v(), *f15_v(); f15_v() ? *f15_v() : *f15_v();
 162   *f15_cv(); *f15_cv(), *f15_cv(); f15_cv() ? *f15_cv() : *f15_cv();
 163   *f15_vv(); *f15_vv(), *f15_vv(); f15_vv() ? *f15_vv() : *f15_vv();
 164   // CHECK-NOT: load
 165   // CHECK: ret void
 166 }
 167
 168 // PR8967: this was crashing
 169 // CHECK-LABEL: define{{.*}} void @f16()
 170 void f16(void) {
 171   __extension__({ goto lbl; });
 172  lbl:
 173   ;
 174 }
 175
 176 // PR13704: negative increment in i128 is not preserved.
 177 // CHECK-LABEL: define{{.*}} void @f17()
 178 void f17(void) {
 179   extern void extfunc(__int128);
 180   __int128 x = 2;
 181   x--;
 182   extfunc(x);
 183 // CHECK: add nsw i128 %{{.}}, -1
 184 }
 185
 186 // PR23597: We should evaluate union cast operands even if the cast is unused.
 187 typedef union u {
 188     int i;
 189 } strct;
 190 int returns_int(void);
 191 void f18(void) {
 192   (strct)returns_int();
 193 }
 194 // CHECK-LABEL: define{{.*}} void @f18()
 195 // CHECK: call i32 @returns_int()
 196
 197 // Ensure the right stmt is returned
 198 int f19(void) {
 199   return ({ 3;;4;; });
 200 }
 201 // CHECK-LABEL: define{{.*}} i32 @f19()
 202 // CHECK: [[T:%.*]] = alloca i32
 203 // CHECK: store i32 4, ptr [[T]]
 204 // CHECK: [[L:%.*]] = load i32, ptr [[T]]
 205 // CHECK: ret i32 [[L]]