Eli Friedman | 5930a4c | 2012-01-05 23:59:40 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -verify -triple x86_64-apple-darwin -emit-llvm -o - %s -std=c++11 | FileCheck %s |
| 2 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 3 | // FIXME: The padding in all these objects should be zero-initialized. |
| 4 | namespace StructUnion { |
| 5 | struct A { |
| 6 | int n; |
| 7 | double d; |
| 8 | union U { |
| 9 | constexpr U(int x) : x(x) {} |
| 10 | constexpr U(const char *y) : y(y) {} |
| 11 | int x; |
| 12 | const char *y; |
| 13 | } u; |
| 14 | |
| 15 | constexpr A(int n, double d, int x) : n(n), d(d), u(x) {} |
| 16 | constexpr A(int n, double d, const char *y) : n(n), d(d), u(y) {} |
| 17 | }; |
| 18 | |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 19 | // CHECK: @_ZN11StructUnion1aE = constant {{.*}} { i32 1, double 2.000000e+00, {{.*}} { i32 3, [4 x i8] undef } } |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 20 | extern constexpr A a(1, 2.0, 3); |
| 21 | |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 22 | // CHECK: @_ZN11StructUnion1bE = constant {{.*}} { i32 4, double 5.000000e+00, {{.*}} { i8* getelementptr inbounds ([6 x i8]* @{{.*}}, i32 0, i32 0) } } |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 23 | extern constexpr A b(4, 5, "hello"); |
| 24 | |
| 25 | struct B { |
| 26 | int n; |
| 27 | }; |
| 28 | |
| 29 | // CHECK: @_ZN11StructUnion1cE = global {{.*}} zeroinitializer |
| 30 | // CHECK: @_ZN11StructUnion2c2E = global {{.*}} zeroinitializer |
| 31 | B c; |
| 32 | B c2 = B(); |
| 33 | |
| 34 | // CHECK: @_ZN11StructUnion1dE = global {{.*}} zeroinitializer |
| 35 | B d[10]; |
| 36 | |
| 37 | struct C { |
| 38 | constexpr C() : c(0) {} |
| 39 | int c; |
| 40 | }; |
| 41 | |
| 42 | // CHECK: @_ZN11StructUnion1eE = global {{.*}} zeroinitializer |
| 43 | C e[10]; |
| 44 | |
| 45 | struct D { |
| 46 | constexpr D() : d(5) {} |
| 47 | int d; |
| 48 | }; |
| 49 | |
| 50 | // CHECK: @_ZN11StructUnion1fE = global {{.*}} { i32 5 } |
| 51 | D f; |
Richard Smith | d079abf | 2012-05-07 01:07:30 +0000 | [diff] [blame] | 52 | |
| 53 | union E { |
| 54 | int a; |
| 55 | void *b = &f; |
| 56 | }; |
| 57 | |
| 58 | // CHECK: @_ZN11StructUnion1gE = global {{.*}} @_ZN11StructUnion1fE |
| 59 | E g; |
| 60 | |
| 61 | // CHECK: @_ZN11StructUnion1hE = global {{.*}} @_ZN11StructUnion1fE |
| 62 | E h = E(); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 63 | } |
| 64 | |
| 65 | namespace BaseClass { |
| 66 | template<typename T, unsigned> struct X : T {}; |
| 67 | struct C { char c = 1; }; |
| 68 | template<unsigned... Ns> struct Cs : X<C,Ns>... {}; |
| 69 | struct N { int n = 3; }; |
| 70 | struct D { double d = 4.0; }; |
| 71 | |
| 72 | template<typename ...Ts> |
| 73 | struct Test : Ts... { constexpr Test() : Ts()..., n(5) {} int n; }; |
| 74 | |
| 75 | using Test1 = Test<N, C, Cs<1,2>, D, X<C,1>>; |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 76 | // CHECK: @_ZN9BaseClass2t1E = constant {{.*}} { i32 3, i8 1, i8 1, i8 1, double 4.000000e+00, i8 1, i32 5 }, align 8 |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 77 | extern constexpr Test1 t1 = Test1(); |
| 78 | |
| 79 | struct DN : D, N {}; |
| 80 | struct DND : DN, X<D,0> {}; |
| 81 | struct DNN : DN, X<N,0> {}; |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 82 | // CHECK: @_ZN9BaseClass3dndE = constant {{.*}} { double 4.000000e+00, i32 3, double 4.000000e+00 } |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 83 | extern constexpr DND dnd = DND(); |
| 84 | // Note, N subobject is laid out in DN subobject's tail padding. |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 85 | // CHECK: @_ZN9BaseClass3dnnE = constant {{.*}} { double 4.000000e+00, i32 3, i32 3 } |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 86 | extern constexpr DNN dnn = DNN(); |
| 87 | |
| 88 | struct E {}; |
| 89 | struct Test2 : X<E,0>, X<E,1>, X<E,2>, X<E,3> {}; |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 90 | // CHECK: @_ZN9BaseClass2t2E = constant {{.*}} undef |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 91 | extern constexpr Test2 t2 = Test2(); |
Eli Friedman | 5fe61c6 | 2012-03-30 03:55:31 +0000 | [diff] [blame] | 92 | |
| 93 | struct __attribute((packed)) PackedD { double y = 2; }; |
| 94 | struct Test3 : C, PackedD { constexpr Test3() {} }; |
| 95 | // CHECK: @_ZN9BaseClass2t3E = constant <{ i8, double }> <{ i8 1, double 2.000000e+00 }> |
| 96 | extern constexpr Test3 t3 = Test3(); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | namespace Array { |
| 100 | // CHECK: @_ZN5Array3arrE = constant [2 x i32] [i32 4, i32 0] |
| 101 | extern constexpr int arr[2] = { 4 }; |
| 102 | |
| 103 | // CHECK: @_ZN5Array1cE = constant [6 x [4 x i8]] [{{.*}} c"foo\00", [4 x i8] c"a\00\00\00", [4 x i8] c"bar\00", [4 x i8] c"xyz\00", [4 x i8] c"b\00\00\00", [4 x i8] c"123\00"] |
| 104 | extern constexpr char c[6][4] = { "foo", "a", { "bar" }, { 'x', 'y', 'z' }, { "b" }, '1', '2', '3' }; |
| 105 | |
Richard Smith | fe58720 | 2012-04-15 02:50:59 +0000 | [diff] [blame] | 106 | // CHECK: @_ZN5Array2ucE = constant [4 x i8] c"foo\00" |
| 107 | extern constexpr unsigned char uc[] = { "foo" }; |
| 108 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 109 | struct C { constexpr C() : n(5) {} int n, m = 3 * n + 1; }; |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 110 | // CHECK: @_ZN5Array5ctorsE = constant [3 x {{.*}}] [{{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }, {{.*}} { i32 5, i32 16 }] |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 111 | extern const C ctors[3]; |
| 112 | constexpr C ctors[3]; |
| 113 | |
| 114 | // CHECK: @_ZN5Array1dE = constant {{.*}} { [2 x i32] [i32 1, i32 2], [3 x i32] [i32 3, i32 4, i32 5] } |
| 115 | struct D { int n[2]; int m[3]; } extern constexpr d = { 1, 2, 3, 4, 5 }; |
Richard Smith | f3908f2 | 2012-02-17 03:35:37 +0000 | [diff] [blame] | 116 | |
| 117 | struct E { |
| 118 | char c[4]; |
| 119 | char d[4]; |
| 120 | constexpr E() : c("foo"), d("x") {} |
| 121 | }; |
Richard Smith | e15c712 | 2012-02-17 04:54:50 +0000 | [diff] [blame] | 122 | // CHECK: @_ZN5Array1eE = constant {{.*}} { [4 x i8] c"foo\00", [4 x i8] c"x\00\00\00" } |
Richard Smith | f3908f2 | 2012-02-17 03:35:37 +0000 | [diff] [blame] | 123 | extern constexpr E e = E(); |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | namespace MemberPtr { |
| 127 | struct B1 { |
| 128 | int a, b; |
| 129 | virtual void f(); |
| 130 | void g(); |
| 131 | }; |
| 132 | struct B2 { |
| 133 | int c, d; |
| 134 | virtual void h(); |
| 135 | void i(); |
| 136 | }; |
| 137 | struct C : B1 { |
| 138 | int e; |
| 139 | virtual void j(); |
| 140 | void k(); |
| 141 | }; |
| 142 | struct D : C, B2 { |
| 143 | int z; |
| 144 | virtual void l(); |
| 145 | void m(); |
| 146 | }; |
| 147 | |
| 148 | // CHECK: @_ZN9MemberPtr2daE = constant i64 8 |
| 149 | // CHECK: @_ZN9MemberPtr2dbE = constant i64 12 |
| 150 | // CHECK: @_ZN9MemberPtr2dcE = constant i64 32 |
| 151 | // CHECK: @_ZN9MemberPtr2ddE = constant i64 36 |
| 152 | // CHECK: @_ZN9MemberPtr2deE = constant i64 16 |
| 153 | // CHECK: @_ZN9MemberPtr2dzE = constant i64 40 |
| 154 | extern constexpr int (D::*da) = &B1::a; |
| 155 | extern constexpr int (D::*db) = &C::b; |
| 156 | extern constexpr int (D::*dc) = &B2::c; |
| 157 | extern constexpr int (D::*dd) = &D::d; |
| 158 | extern constexpr int (D::*de) = &C::e; |
| 159 | extern constexpr int (D::*dz) = &D::z; |
| 160 | |
| 161 | // CHECK: @_ZN9MemberPtr2baE = constant i64 8 |
| 162 | // CHECK: @_ZN9MemberPtr2bbE = constant i64 12 |
| 163 | // CHECK: @_ZN9MemberPtr2bcE = constant i64 8 |
| 164 | // CHECK: @_ZN9MemberPtr2bdE = constant i64 12 |
| 165 | // CHECK: @_ZN9MemberPtr2beE = constant i64 16 |
| 166 | // CHECK: @_ZN9MemberPtr3b1zE = constant i64 40 |
| 167 | // CHECK: @_ZN9MemberPtr3b2zE = constant i64 16 |
| 168 | extern constexpr int (B1::*ba) = (int(B1::*))&B1::a; |
| 169 | extern constexpr int (B1::*bb) = (int(B1::*))&C::b; |
| 170 | extern constexpr int (B2::*bc) = (int(B2::*))&B2::c; |
| 171 | extern constexpr int (B2::*bd) = (int(B2::*))&D::d; |
| 172 | extern constexpr int (B1::*be) = (int(B1::*))&C::e; |
| 173 | extern constexpr int (B1::*b1z) = (int(B1::*))&D::z; |
| 174 | extern constexpr int (B2::*b2z) = (int(B2::*))&D::z; |
| 175 | |
| 176 | // CHECK: @_ZN9MemberPtr2dfE = constant {{.*}} { i64 1, i64 0 } |
| 177 | // CHECK: @_ZN9MemberPtr2dgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 } |
| 178 | // CHECK: @_ZN9MemberPtr2dhE = constant {{.*}} { i64 1, i64 24 } |
| 179 | // CHECK: @_ZN9MemberPtr2diE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 24 } |
| 180 | // CHECK: @_ZN9MemberPtr2djE = constant {{.*}} { i64 9, i64 0 } |
| 181 | // CHECK: @_ZN9MemberPtr2dkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 } |
| 182 | // CHECK: @_ZN9MemberPtr2dlE = constant {{.*}} { i64 17, i64 0 } |
| 183 | // CHECK: @_ZN9MemberPtr2dmE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 } |
| 184 | extern constexpr void (D::*df)() = &C::f; |
| 185 | extern constexpr void (D::*dg)() = &B1::g; |
| 186 | extern constexpr void (D::*dh)() = &B2::h; |
| 187 | extern constexpr void (D::*di)() = &D::i; |
| 188 | extern constexpr void (D::*dj)() = &C::j; |
| 189 | extern constexpr void (D::*dk)() = &C::k; |
| 190 | extern constexpr void (D::*dl)() = &D::l; |
| 191 | extern constexpr void (D::*dm)() = &D::m; |
| 192 | |
| 193 | // CHECK: @_ZN9MemberPtr2bfE = constant {{.*}} { i64 1, i64 0 } |
| 194 | // CHECK: @_ZN9MemberPtr2bgE = constant {{.*}} { i64 {{.*}}2B11gEv{{.*}}, i64 0 } |
| 195 | // CHECK: @_ZN9MemberPtr2bhE = constant {{.*}} { i64 1, i64 0 } |
| 196 | // CHECK: @_ZN9MemberPtr2biE = constant {{.*}} { i64 {{.*}}2B21iEv{{.*}}, i64 0 } |
| 197 | // CHECK: @_ZN9MemberPtr2bjE = constant {{.*}} { i64 9, i64 0 } |
| 198 | // CHECK: @_ZN9MemberPtr2bkE = constant {{.*}} { i64 {{.*}}1C1kEv{{.*}}, i64 0 } |
| 199 | // CHECK: @_ZN9MemberPtr3b1lE = constant {{.*}} { i64 17, i64 0 } |
| 200 | // CHECK: @_ZN9MemberPtr3b1mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 0 } |
| 201 | // CHECK: @_ZN9MemberPtr3b2lE = constant {{.*}} { i64 17, i64 -24 } |
| 202 | // CHECK: @_ZN9MemberPtr3b2mE = constant {{.*}} { i64 {{.*}}1D1mEv{{.*}}, i64 -24 } |
| 203 | extern constexpr void (B1::*bf)() = (void(B1::*)())&C::f; |
| 204 | extern constexpr void (B1::*bg)() = (void(B1::*)())&B1::g; |
| 205 | extern constexpr void (B2::*bh)() = (void(B2::*)())&B2::h; |
| 206 | extern constexpr void (B2::*bi)() = (void(B2::*)())&D::i; |
| 207 | extern constexpr void (B1::*bj)() = (void(B1::*)())&C::j; |
| 208 | extern constexpr void (B1::*bk)() = (void(B1::*)())&C::k; |
| 209 | extern constexpr void (B1::*b1l)() = (void(B1::*)())&D::l; |
| 210 | extern constexpr void (B1::*b1m)() = (void(B1::*)())&D::m; |
| 211 | extern constexpr void (B2::*b2l)() = (void(B2::*)())&D::l; |
| 212 | extern constexpr void (B2::*b2m)() = (void(B2::*)())&D::m; |
| 213 | } |
| 214 | |
Richard Smith | 7ca4850 | 2012-02-13 22:16:19 +0000 | [diff] [blame] | 215 | namespace LiteralReference { |
| 216 | struct Lit { |
| 217 | constexpr Lit() : n(5) {} |
| 218 | int n; |
| 219 | }; |
| 220 | // FIXME: This should have static initialization, but we do not implement |
| 221 | // that yet. For now, just check that we don't set the (pointer) value of |
| 222 | // the reference to 5! |
| 223 | // |
| 224 | // CHECK: @_ZN16LiteralReference3litE = global {{.*}} null |
| 225 | const Lit &lit = Lit(); |
| 226 | } |
| 227 | |
| 228 | namespace NonLiteralConstexpr { |
| 229 | constexpr int factorial(int n) { |
| 230 | return n ? factorial(n-1) * n : 1; |
| 231 | } |
| 232 | extern void f(int *p); |
| 233 | |
| 234 | struct NonTrivialDtor { |
| 235 | constexpr NonTrivialDtor() : n(factorial(5)), p(&n) {} |
| 236 | ~NonTrivialDtor() { |
| 237 | f(p); |
| 238 | } |
| 239 | |
| 240 | int n; |
| 241 | int *p; |
| 242 | }; |
| 243 | static_assert(!__is_literal(NonTrivialDtor), ""); |
| 244 | // CHECK: @_ZN19NonLiteralConstexpr3ntdE = global {{.*}} { i32 120, i32* getelementptr |
| 245 | NonTrivialDtor ntd; |
| 246 | |
| 247 | struct VolatileMember { |
| 248 | constexpr VolatileMember() : n(5) {} |
| 249 | volatile int n; |
| 250 | }; |
| 251 | static_assert(!__is_literal(VolatileMember), ""); |
| 252 | // CHECK: @_ZN19NonLiteralConstexpr2vmE = global {{.*}} { i32 5 } |
| 253 | VolatileMember vm; |
| 254 | |
| 255 | struct Both { |
| 256 | constexpr Both() : n(10) {} |
| 257 | ~Both(); |
| 258 | volatile int n; |
| 259 | }; |
| 260 | // CHECK: @_ZN19NonLiteralConstexpr1bE = global {{.*}} { i32 10 } |
| 261 | Both b; |
| 262 | |
| 263 | void StaticVars() { |
| 264 | // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE3ntd = {{.*}} { i32 120, i32* getelementptr {{.*}} |
| 265 | // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE3ntd = |
| 266 | static NonTrivialDtor ntd; |
| 267 | // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE2vm = {{.*}} { i32 5 } |
| 268 | // CHECK-NOT: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE2vm = |
| 269 | static VolatileMember vm; |
| 270 | // CHECK: @_ZZN19NonLiteralConstexpr10StaticVarsEvE1b = {{.*}} { i32 10 } |
| 271 | // CHECK: @_ZGVZN19NonLiteralConstexpr10StaticVarsEvE1b = |
| 272 | static Both b; |
| 273 | } |
| 274 | } |
| 275 | |
Richard Smith | c22adbd | 2012-02-23 08:33:23 +0000 | [diff] [blame] | 276 | // PR12067 |
| 277 | namespace VirtualMembers { |
| 278 | struct A { |
| 279 | constexpr A(double d) : d(d) {} |
| 280 | virtual void f(); |
| 281 | double d; |
| 282 | }; |
| 283 | struct B : A { |
| 284 | constexpr B() : A(2.0), c{'h', 'e', 'l', 'l', 'o'} {} |
| 285 | constexpr B(int n) : A(n), c{'w', 'o', 'r', 'l', 'd'} {} |
| 286 | virtual void g(); |
| 287 | char c[5]; |
| 288 | }; |
| 289 | struct C { |
| 290 | constexpr C() : n(64) {} |
| 291 | int n; |
| 292 | }; |
| 293 | struct D : C, A, B { |
| 294 | constexpr D() : A(1.0), B(), s(5) {} |
| 295 | short s; |
| 296 | }; |
| 297 | struct E : D, B { |
| 298 | constexpr E() : B(3), c{'b','y','e'} {} |
| 299 | char c[3]; |
| 300 | }; |
| 301 | |
| 302 | // CHECK: @_ZN14VirtualMembers1eE = global { i8**, double, i32, i8**, double, [5 x i8], i16, i8**, double, [5 x i8], [3 x i8] } { i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 2), double 1.000000e+00, i32 64, i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 5), double 2.000000e+00, [5 x i8] c"hello", i16 5, i8** getelementptr inbounds ([11 x i8*]* @_ZTVN14VirtualMembers1EE, i64 0, i64 9), double 3.000000e+00, [5 x i8] c"world", [3 x i8] c"bye" } |
| 303 | E e; |
| 304 | |
| 305 | struct nsMemoryImpl { |
| 306 | virtual void f(); |
| 307 | }; |
| 308 | // CHECK: @_ZN14VirtualMembersL13sGlobalMemoryE = internal global { i8** } { i8** getelementptr inbounds ([3 x i8*]* @_ZTVN14VirtualMembers12nsMemoryImplE, i64 0, i64 2) } |
| 309 | static nsMemoryImpl sGlobalMemory; |
| 310 | } |
| 311 | |
Richard Smith | f4bb8d0 | 2012-07-05 08:39:21 +0000 | [diff] [blame^] | 312 | namespace PR13273 { |
| 313 | struct U { |
| 314 | int t; |
| 315 | U() = default; |
| 316 | }; |
| 317 | |
| 318 | struct S : U { |
| 319 | S() = default; |
| 320 | }; |
| 321 | |
| 322 | // CHECK: @_ZN7PR13273L1sE = {{.*}} zeroinitializer |
| 323 | const S s {}; |
| 324 | } |
| 325 | |
Richard Smith | 2d6a567 | 2012-01-14 04:30:29 +0000 | [diff] [blame] | 326 | // Constant initialization tests go before this point, |
| 327 | // dynamic initialization tests go after. |
| 328 | |
Richard Smith | 7ca4850 | 2012-02-13 22:16:19 +0000 | [diff] [blame] | 329 | // We must emit a constant initializer for NonLiteralConstexpr::ntd, but also |
| 330 | // emit an initializer to register its destructor. |
| 331 | // CHECK: define {{.*}}cxx_global_var_init{{.*}} |
| 332 | // CHECK-NOT: NonLiteralConstexpr |
| 333 | // CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev {{.*}} @_ZN19NonLiteralConstexpr3ntdE |
| 334 | // CHECK-NEXT: ret void |
| 335 | |
| 336 | // We don't need to emit any dynamic initialization for NonLiteralConstexpr::vm. |
| 337 | // CHECK-NOT: NonLiteralConstexpr2vm |
| 338 | |
| 339 | // We must emit a constant initializer for NonLiteralConstexpr::b, but also |
| 340 | // emit an initializer to register its destructor. |
| 341 | // CHECK: define {{.*}}cxx_global_var_init{{.*}} |
| 342 | // CHECK-NOT: NonLiteralConstexpr |
| 343 | // CHECK: call {{.*}}cxa_atexit{{.*}} @_ZN19NonLiteralConstexpr4BothD1Ev {{.*}} @_ZN19NonLiteralConstexpr1bE |
| 344 | // CHECK-NEXT: ret void |
| 345 | |
| 346 | // CHECK: define {{.*}}NonLiteralConstexpr10StaticVars |
| 347 | // CHECK-NOT: } |
| 348 | // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr14NonTrivialDtorD1Ev |
| 349 | // CHECK-NOT: } |
| 350 | // CHECK: call {{.*}}cxa_atexit{{.*}}@_ZN19NonLiteralConstexpr4BothD1Ev |
| 351 | |
Eli Friedman | 5930a4c | 2012-01-05 23:59:40 +0000 | [diff] [blame] | 352 | namespace CrossFuncLabelDiff { |
| 353 | // Make sure we refuse to constant-fold the variable b. |
Richard Smith | 745f514 | 2012-01-27 01:14:48 +0000 | [diff] [blame] | 354 | constexpr long a(bool x) { return x ? 0 : (long)&&lbl + (0 && ({lbl: 0;})); } |
| 355 | void test() { static long b = (long)&&lbl - a(false); lbl: return; } |
Eli Friedman | 5930a4c | 2012-01-05 23:59:40 +0000 | [diff] [blame] | 356 | // CHECK: sub nsw i64 ptrtoint (i8* blockaddress(@_ZN18CrossFuncLabelDiff4testEv, {{.*}}) to i64), |
| 357 | // CHECK: store i64 {{.*}}, i64* @_ZZN18CrossFuncLabelDiff4testEvE1b, align 8 |
| 358 | } |
Richard Smith | ce582fe | 2012-02-17 00:44:16 +0000 | [diff] [blame] | 359 | |
| 360 | // PR12012 |
| 361 | namespace VirtualBase { |
| 362 | struct B {}; |
| 363 | struct D : virtual B {}; |
| 364 | D d; |
| 365 | // CHECK: call {{.*}}@_ZN11VirtualBase1DC1Ev |
| 366 | |
| 367 | template<typename T> struct X : T { |
| 368 | constexpr X() : T() {} |
| 369 | }; |
| 370 | X<D> x; |
| 371 | // CHECK: call {{.*}}@_ZN11VirtualBase1XINS_1DEEC1Ev |
| 372 | } |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 373 | |
| 374 | // PR12145 |
| 375 | namespace Unreferenced { |
| 376 | int n; |
| 377 | constexpr int *p = &n; |
| 378 | // We must not emit a load of 'p' here, since it's not odr-used. |
| 379 | int q = *p; |
| 380 | // CHECK-NOT: _ZN12Unreferenced1pE |
| 381 | // CHECK: = load i32* @_ZN12Unreferenced1nE |
| 382 | // CHECK-NEXT: store i32 {{.*}}, i32* @_ZN12Unreferenced1qE |
| 383 | // CHECK-NOT: _ZN12Unreferenced1pE |
| 384 | |
| 385 | // Technically, we are not required to substitute variables of reference types |
| 386 | // initialized by constant expressions, because the special case for odr-use |
| 387 | // of variables in [basic.def.odr]p2 only applies to objects. But we do so |
| 388 | // anyway. |
| 389 | |
| 390 | constexpr int &r = n; |
| 391 | // CHECK-NOT: _ZN12Unreferenced1rE |
| 392 | int s = r; |
| 393 | |
| 394 | const int t = 1; |
| 395 | const int &rt = t; |
| 396 | int f(int); |
| 397 | int u = f(rt); |
| 398 | // CHECK: call i32 @_ZN12Unreferenced1fEi(i32 1) |
| 399 | } |
| 400 | |
| 401 | namespace InitFromConst { |
| 402 | template<typename T> void consume(T); |
| 403 | |
| 404 | const bool b = true; |
| 405 | const int n = 5; |
Richard Smith | 946e272 | 2012-03-07 01:58:44 +0000 | [diff] [blame] | 406 | constexpr double d = 4.3; |
Richard Smith | a3ca41f | 2012-03-02 23:27:11 +0000 | [diff] [blame] | 407 | |
| 408 | struct S { int n = 7; S *p = 0; }; |
| 409 | constexpr S s = S(); |
| 410 | const S &r = s; |
| 411 | constexpr const S *p = &r; |
| 412 | constexpr int S::*mp = &S::n; |
| 413 | constexpr int a[3] = { 1, 4, 9 }; |
| 414 | |
| 415 | void test() { |
| 416 | // CHECK: call void @_ZN13InitFromConst7consumeIbEEvT_(i1 zeroext true) |
| 417 | consume(b); |
| 418 | |
| 419 | // CHECK: call void @_ZN13InitFromConst7consumeIiEEvT_(i32 5) |
| 420 | consume(n); |
| 421 | |
| 422 | // CHECK: call void @_ZN13InitFromConst7consumeIdEEvT_(double 4.300000e+00) |
| 423 | consume(d); |
| 424 | |
| 425 | // CHECK: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) |
| 426 | consume<const S&>(s); |
| 427 | |
| 428 | // FIXME CHECK-NOT: call void @_ZN13InitFromConst7consumeIRKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) |
| 429 | // There's no lvalue-to-rvalue conversion here, so 'r' is odr-used, and |
| 430 | // we're permitted to emit a load of it. This seems likely to be a defect |
| 431 | // in the standard. If we start emitting a direct reference to 's', update |
| 432 | // this test. |
| 433 | consume<const S&>(r); |
| 434 | |
| 435 | // CHECK: call void @_ZN13InitFromConst7consumeIPKNS_1SEEEvT_(%"struct.InitFromConst::S"* @_ZN13InitFromConstL1sE) |
| 436 | consume(p); |
| 437 | |
| 438 | // CHECK: call void @_ZN13InitFromConst7consumeIMNS_1SEiEEvT_(i64 0) |
| 439 | consume(mp); |
| 440 | |
| 441 | // CHECK: call void @_ZN13InitFromConst7consumeIPKiEEvT_(i32* getelementptr inbounds ([3 x i32]* @_ZN13InitFromConstL1aE, i32 0, i32 0)) |
| 442 | consume(a); |
| 443 | } |
| 444 | } |
Richard Smith | 49149fe | 2012-04-08 08:02:07 +0000 | [diff] [blame] | 445 | |
| 446 | namespace Null { |
| 447 | decltype(nullptr) null(); |
| 448 | // CHECK: call {{.*}} @_ZN4Null4nullEv( |
| 449 | int *p = null(); |
| 450 | struct S {}; |
| 451 | // CHECK: call {{.*}} @_ZN4Null4nullEv( |
| 452 | int S::*q = null(); |
| 453 | } |