зеркало из https://github.com/microsoft/clang-1.git
300 строки
5.1 KiB
C++
300 строки
5.1 KiB
C++
// RUN: %clang_cc1 -triple x86_64-apple-darwin -verify -emit-llvm -o - %s | FileCheck %s
|
|
void t1() {
|
|
extern int& a;
|
|
int b = a;
|
|
}
|
|
|
|
void t2(int& a) {
|
|
int b = a;
|
|
}
|
|
|
|
int g;
|
|
int& gr = g;
|
|
int& grr = gr;
|
|
void t3() {
|
|
int b = gr;
|
|
}
|
|
|
|
// Test reference binding.
|
|
|
|
struct C { int a; };
|
|
void f(const bool&);
|
|
void f(const int&);
|
|
void f(const _Complex int&);
|
|
void f(const C&);
|
|
|
|
C aggregate_return();
|
|
|
|
bool& bool_reference_return();
|
|
int& int_reference_return();
|
|
_Complex int& complex_int_reference_return();
|
|
C& aggregate_reference_return();
|
|
|
|
void test_bool() {
|
|
bool a = true;
|
|
f(a);
|
|
|
|
f(true);
|
|
|
|
bool_reference_return() = true;
|
|
a = bool_reference_return();
|
|
|
|
struct { const bool& b; } b = { true };
|
|
}
|
|
|
|
void test_scalar() {
|
|
int a = 10;
|
|
f(a);
|
|
|
|
struct { int bitfield : 3; } s = { 3 };
|
|
f(s.bitfield);
|
|
|
|
f(10);
|
|
|
|
__attribute((vector_size(16))) typedef int vec4;
|
|
f((vec4){1,2,3,4}[0]);
|
|
|
|
int_reference_return() = 10;
|
|
a = int_reference_return();
|
|
|
|
struct { const int& a; } agg = { 10 };
|
|
}
|
|
|
|
void test_complex() {
|
|
_Complex int a = 10i;
|
|
f(a);
|
|
|
|
f(10i);
|
|
|
|
complex_int_reference_return() = 10i;
|
|
a = complex_int_reference_return();
|
|
|
|
struct { const _Complex int &a; } agg = { 10i };
|
|
}
|
|
|
|
void test_aggregate() {
|
|
C c;
|
|
f(c);
|
|
|
|
f(aggregate_return());
|
|
aggregate_reference_return().a = 10;
|
|
|
|
c = aggregate_reference_return();
|
|
|
|
struct { const C& a; } agg = { C() };
|
|
}
|
|
|
|
int& reference_return() {
|
|
return g;
|
|
}
|
|
|
|
int reference_decl() {
|
|
int& a = g;
|
|
const int& b = 1;
|
|
return a+b;
|
|
}
|
|
|
|
struct A {
|
|
int& b();
|
|
};
|
|
|
|
void f(A* a) {
|
|
int b = a->b();
|
|
}
|
|
|
|
// PR5122
|
|
void *foo = 0;
|
|
void * const & kFoo = foo;
|
|
|
|
struct D : C { D(); ~D(); };
|
|
|
|
void h() {
|
|
// CHECK: call void @_ZN1DD1Ev
|
|
const C& c = D();
|
|
}
|
|
|
|
namespace T {
|
|
struct A {
|
|
A();
|
|
~A();
|
|
};
|
|
|
|
struct B {
|
|
B();
|
|
~B();
|
|
A f();
|
|
};
|
|
|
|
void f() {
|
|
// CHECK: call void @_ZN1T1BC1Ev
|
|
// CHECK: call void @_ZN1T1B1fEv
|
|
// CHECK: call void @_ZN1T1BD1Ev
|
|
const A& a = B().f();
|
|
// CHECK: call void @_ZN1T1fEv
|
|
f();
|
|
// CHECK: call void @_ZN1T1AD1Ev
|
|
}
|
|
}
|
|
|
|
// PR5227.
|
|
namespace PR5227 {
|
|
void f(int &a) {
|
|
(a = 10) = 20;
|
|
}
|
|
}
|
|
|
|
// PR5590
|
|
struct s0;
|
|
struct s1 { struct s0 &s0; };
|
|
void f0(s1 a) { s1 b = a; }
|
|
|
|
// PR6024
|
|
// CHECK: @_Z2f2v()
|
|
// CHECK: alloca i32,
|
|
// CHECK-NEXT: store
|
|
// CHECK-NEXT: ret
|
|
const int &f2() { return 0; }
|
|
|
|
// Don't constant fold const reference parameters with default arguments to
|
|
// their default arguments.
|
|
namespace N1 {
|
|
const int foo = 1;
|
|
// CHECK: @_ZN2N14test
|
|
void test(const int& arg = foo) {
|
|
// Ensure this array is on the stack where we can set values instead of
|
|
// being a global constant.
|
|
// CHECK: %args_array = alloca
|
|
const int* const args_array[] = { &arg };
|
|
}
|
|
}
|
|
|
|
// Bind to subobjects while extending the life of the complete object.
|
|
namespace N2 {
|
|
class X {
|
|
public:
|
|
X(const X&);
|
|
X &operator=(const X&);
|
|
~X();
|
|
};
|
|
|
|
struct P {
|
|
X first;
|
|
};
|
|
|
|
P getP();
|
|
|
|
// CHECK: define void @_ZN2N21fEi
|
|
// CHECK: call void @_ZN2N24getPEv
|
|
// CHECK: getelementptr inbounds
|
|
// CHECK: store i32 17
|
|
// CHECK: call void @_ZN2N21PD1Ev
|
|
void f(int i) {
|
|
const X& xr = getP().first;
|
|
i = 17;
|
|
}
|
|
|
|
struct SpaceWaster {
|
|
int i, j;
|
|
};
|
|
|
|
struct ReallyHasX {
|
|
X x;
|
|
};
|
|
|
|
struct HasX : ReallyHasX { };
|
|
|
|
struct HasXContainer {
|
|
HasX has;
|
|
};
|
|
|
|
struct Y : SpaceWaster, HasXContainer { };
|
|
struct Z : SpaceWaster, Y { };
|
|
|
|
Z getZ();
|
|
|
|
// CHECK: define void @_ZN2N21gEi
|
|
// CHECK: call void @_ZN2N24getZEv
|
|
// CHECK: {{getelementptr inbounds.*i32 0, i32 0}}
|
|
// CHECK: {{getelementptr inbounds.*i32 0, i32 0}}
|
|
// CHECK: store i32 19
|
|
// CHECK: call void @_ZN2N21ZD1Ev
|
|
// CHECK: ret void
|
|
void g(int i) {
|
|
const X &xr = getZ().has.x;
|
|
i = 19;
|
|
}
|
|
}
|
|
|
|
namespace N3 {
|
|
|
|
// PR7326
|
|
|
|
struct A {
|
|
explicit A(int);
|
|
~A();
|
|
};
|
|
|
|
// CHECK: define internal void @__cxx_global_var_init
|
|
// CHECK: call void @_ZN2N31AC1Ei(%"struct.N3::A"* @_ZGRN2N35sA123E, i32 123)
|
|
// CHECK: call i32 @__cxa_atexit
|
|
// CHECK: ret void
|
|
const A &sA123 = A(123);
|
|
}
|
|
|
|
namespace N4 {
|
|
|
|
struct A {
|
|
A();
|
|
~A();
|
|
};
|
|
|
|
void f() {
|
|
// CHECK: define void @_ZN2N41fEv
|
|
// CHECK: call void @_ZN2N41AC1Ev(%"struct.N4::A"* @_ZGRZN2N41fEvE2ar)
|
|
// CHECK: call i32 @__cxa_atexit
|
|
// CHECK: ret void
|
|
static const A& ar = A();
|
|
|
|
}
|
|
}
|
|
|
|
// PR9494
|
|
namespace N5 {
|
|
struct AnyS { bool b; };
|
|
void f(const bool&);
|
|
AnyS g();
|
|
void h() {
|
|
// CHECK: call i8 @_ZN2N51gEv()
|
|
// CHECK: call void @_ZN2N51fERKb(i8*
|
|
f(g().b);
|
|
}
|
|
}
|
|
|
|
// PR9565
|
|
namespace PR9565 {
|
|
struct a { int a : 10, b : 10; };
|
|
// CHECK: define void @_ZN6PR95651fEv()
|
|
void f() {
|
|
// CHECK: call void @llvm.memcpy
|
|
a x = { 0, 0 };
|
|
// CHECK: [[WITH_SEVENTEEN:%[a-zA-Z0-9]+]] = or i32 [[WITHOUT_SEVENTEEN:%[a-zA-Z0-9]+]], 17
|
|
// CHECK: store i32 [[WITH_SEVENTEEN]], i32* [[XA:%[a-zA-Z0-9]+]]
|
|
x.a = 17;
|
|
// CHECK-NEXT: bitcast
|
|
// CHECK-NEXT: load
|
|
// CHECK-NEXT: and
|
|
// CHECK-NEXT: shl
|
|
// CHECK-NEXT: ashr
|
|
// CHECK-NEXT: store i32
|
|
// CHECK-NEXT: store i32*
|
|
const int &y = x.a;
|
|
// CHECK-NEXT: bitcast
|
|
// CHECK-NEXT: load
|
|
// CHECK-NEXT: and
|
|
// CHECK-NEXT: or
|
|
// CHECK-NEXT: store i32
|
|
x.b = 19;
|
|
// CHECK-NEXT: ret void
|
|
}
|
|
}
|