clang/test/CodeGenCXX/references.cpp

   1 // RUN: not %clang_cc1 -triple x86_64-apple-darwin -verify -emit-llvm -o - %s | FileCheck %s
   2 void t1() {
   3   // CHECK-LABEL: define{{.*}} void @_Z2t1v
   4   // CHECK: [[REFLOAD:%.*]] = load ptr, ptr @a, align 8
   5   // CHECK: load i32, ptr [[REFLOAD]], align 4
   6   extern int& a;
   7   int b = a;
   8 }
   9
  10 void t2(int& a) {
  11   // CHECK-LABEL: define{{.*}} void @_Z2t2Ri
  12   // CHECK: [[REFLOAD2:%.*]] = load ptr, ptr {{.*}}, align 8
  13   // CHECK: load i32, ptr [[REFLOAD2]], align 4
  14   int b = a;
  15 }
  16
  17 int g;
  18 int& gr = g;
  19 int& grr = gr;
  20 void t3() {
  21   int b = gr;
  22 }
  23
  24 // Test reference binding.
  25
  26 struct C { int a; };
  27 void f(const bool&);
  28 void f(const int&);
  29 void f(const _Complex int&);
  30 void f(const C&);
  31
  32 C aggregate_return();
  33
  34 bool& bool_reference_return();
  35 int& int_reference_return();
  36 _Complex int& complex_int_reference_return();
  37 C& aggregate_reference_return();
  38
  39 void test_bool() {
  40   bool a = true;
  41   f(a);
  42
  43   f(true);
  44
  45   bool_reference_return() = true;
  46   a = bool_reference_return();
  47
  48   struct { const bool& b; } b = { true };
  49 }
  50
  51 void test_scalar() {
  52   int a = 10;
  53   f(a);
  54
  55   struct { int bitfield : 3; } s = { 3 };
  56   f(s.bitfield);
  57
  58   f(10);
  59
  60   __attribute((vector_size(16))) typedef int vec4;
  61   f((vec4){1,2,3,4}[0]);
  62
  63   int_reference_return() = 10;
  64   a = int_reference_return();
  65
  66   struct { const int& a; } agg = { 10 };
  67 }
  68
  69 void test_complex() {
  70   _Complex int a = 10i;
  71   f(a);
  72
  73   f(10i);
  74
  75   complex_int_reference_return() = 10i;
  76   a = complex_int_reference_return();
  77
  78   struct { const _Complex int &a; } agg = { 10i };
  79 }
  80
  81 void test_aggregate() {
  82   C c;
  83   f(c);
  84
  85   f(aggregate_return());
  86   aggregate_reference_return().a = 10;
  87
  88   c = aggregate_reference_return();
  89
  90   struct { const C& a; } agg = { C() };
  91 }
  92
  93 int& reference_return() {
  94   return g;
  95 }
  96
  97 int reference_decl() {
  98   int& a = g;
  99   const int& b = 1;
 100   return a+b;
 101 }
 102
 103 struct A {
 104   int& b();
 105 };
 106
 107 void f(A* a) {
 108   int b = a->b();
 109 }
 110
 111 // PR5122
 112 void *foo = 0;
 113 void * const & kFoo = foo;
 114
 115 struct D : C { D(); ~D(); };
 116
 117 void h() {
 118   // CHECK: call void @_ZN1DD1Ev
 119   const C& c = D();
 120 }
 121
 122 namespace T {
 123   struct A {
 124     A();
 125     ~A();
 126   };
 127
 128   struct B {
 129     B();
 130     ~B();
 131     A f();
 132   };
 133
 134   void f() {
 135     // CHECK: call void @_ZN1T1BC1Ev
 136     // CHECK: call void @_ZN1T1B1fEv
 137     // CHECK: call void @_ZN1T1BD1Ev
 138     const A& a = B().f();
 139     // CHECK: call void @_ZN1T1fEv
 140     f();
 141     // CHECK: call void @_ZN1T1AD1Ev
 142   }
 143 }
 144
 145 // PR5227.
 146 namespace PR5227 {
 147 void f(int &a) {
 148   (a = 10) = 20;
 149 }
 150 }
 151
 152 // PR5590
 153 struct s0;
 154 struct s1 { struct s0 &s0; };
 155 void f0(s1 a) { s1 b = a; }
 156
 157 // PR6024
 158 // CHECK: @_Z2f2v()
 159 // CHECK: alloca i32,
 160 // CHECK-NEXT: store
 161 // CHECK-NEXT: ret
 162 const int &f2() { return 0; }
 163
 164 // Don't constant fold const reference parameters with default arguments to
 165 // their default arguments.
 166 namespace N1 {
 167   const int foo = 1;
 168   // CHECK: @_ZN2N14test
 169   void test(const int& arg = foo) {
 170     // Ensure this array is on the stack where we can set values instead of
 171     // being a global constant.
 172     // CHECK: %args_array = alloca
 173     const int* const args_array[] = { &arg };
 174   }
 175 }
 176
 177 // Bind to subobjects while extending the life of the complete object.
 178 namespace N2 {
 179   class X {
 180   public:
 181     X(const X&);
 182     X &operator=(const X&);
 183     ~X();
 184   };
 185
 186   struct P {
 187     X first;
 188   };
 189
 190   P getP();
 191
 192   // CHECK-LABEL: define{{.*}} void @_ZN2N21fEi
 193   // CHECK: call void @_ZN2N24getPEv
 194   // CHECK: getelementptr inbounds
 195   // CHECK: store i32 17
 196   // CHECK: call void @_ZN2N21PD1Ev
 197   void f(int i) {
 198     const X& xr = getP().first;
 199     i = 17;
 200   }
 201
 202   struct SpaceWaster {
 203     int i, j;
 204   };
 205
 206   struct ReallyHasX {
 207     X x;
 208   };
 209
 210   struct HasX : ReallyHasX { };
 211
 212   struct HasXContainer {
 213     HasX has;
 214   };
 215
 216   struct Y : SpaceWaster, HasXContainer { };
 217   struct Z : SpaceWaster, Y { };
 218
 219   Z getZ();
 220
 221   // CHECK-LABEL: define{{.*}} void @_ZN2N21gEi
 222   // CHECK: call void @_ZN2N24getZEv
 223   // CHECK: {{getelementptr inbounds.*i32 0, i32 0}}
 224   // CHECK: {{getelementptr inbounds.*i32 0, i32 0}}
 225   // CHECK: store i32 19
 226   // CHECK: call void @_ZN2N21ZD1Ev
 227   // CHECK: ret void
 228   void g(int i) {
 229     const X &xr = getZ().has.x;
 230     i = 19;
 231   }
 232 }
 233
 234 namespace N3 {
 235
 236 // PR7326
 237
 238 struct A {
 239   explicit A(int);
 240   ~A();
 241 };
 242
 243 // CHECK-LABEL: define internal void @__cxx_global_var_init
 244 // CHECK: call void @_ZN2N31AC1Ei(ptr {{[^,]*}} @_ZGRN2N35sA123E_, i32 noundef 123)
 245 // CHECK: call i32 @__cxa_atexit
 246 // CHECK: ret void
 247 const A &sA123 = A(123);
 248 }
 249
 250 namespace N4 {
 251
 252 struct A {
 253   A();
 254   ~A();
 255 };
 256
 257 void f() {
 258   // CHECK-LABEL: define{{.*}} void @_ZN2N41fEv
 259   // CHECK: call void @_ZN2N41AC1Ev(ptr {{[^,]*}} @_ZGRZN2N41fEvE2ar_)
 260   // CHECK: call i32 @__cxa_atexit
 261   // CHECK: ret void
 262   static const A& ar = A();
 263
 264 }
 265 }
 266
 267 // PR9494
 268 namespace N5 {
 269 struct AnyS { bool b; };
 270 void f(const bool&);
 271 AnyS g();
 272 void h() {
 273   // CHECK: call i8 @_ZN2N51gEv()
 274   // CHECK: call void @_ZN2N51fERKb(ptr
 275   f(g().b);
 276 }
 277 }
 278
 279 // PR9565
 280 namespace PR9565 {
 281   struct a { int a : 10, b : 10; };
 282   // CHECK-LABEL: define{{.*}} void @_ZN6PR95651fEv()
 283   void f() {
 284     // CHECK: call void @llvm.memcpy
 285     a x = { 0, 0 };
 286     // CHECK: [[WITH_SEVENTEEN:%[.a-zA-Z0-9]+]] = or i32 [[WITHOUT_SEVENTEEN:%[.a-zA-Z0-9]+]], 17
 287     // CHECK: store i32 [[WITH_SEVENTEEN]], ptr [[XA:%[.a-zA-Z0-9]+]]
 288     x.a = 17;
 289     // CHECK-NEXT: load
 290     // CHECK-NEXT: shl
 291     // CHECK-NEXT: ashr
 292     // CHECK-NEXT: store i32
 293     // CHECK-NEXT: store ptr
 294     const int &y = x.a;
 295     // CHECK-NEXT: load
 296     // CHECK-NEXT: and
 297     // CHECK-NEXT: or i32 {{.*}}, 19456
 298     // CHECK-NEXT: store i32
 299     x.b = 19;
 300     // CHECK-NEXT: ret void
 301   }
 302 }
 303
 304 namespace N6 {
 305   extern struct x {char& x;}y;
 306   int a() { return y.x; }
 307   // CHECK-LABEL: define{{.*}} i32 @_ZN2N61aEv
 308   // CHECK: [[REFLOAD3:%.*]] = load ptr, ptr @_ZN2N61yE, align 8
 309   // CHECK: load i8, ptr [[REFLOAD3]], align 1
 310 }