Anders Carlsson | f28c687 | 2009-12-23 22:31:44 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-apple-darwin9 -fblocks | FileCheck %s |
Douglas Gregor | 5f2bfd4 | 2009-02-13 00:10:09 +0000 | [diff] [blame] | 2 | struct X { }; |
| 3 | struct Y { }; |
Anders Carlsson | b1d947b | 2009-03-07 23:57:03 +0000 | [diff] [blame] | 4 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 5 | // CHECK: @unmangled_variable = global |
| 6 | // CHECK: @_ZN1N1iE = global |
| 7 | // CHECK: @_ZZN1N1fEiiE1b = internal global |
| 8 | // CHECK: @_ZZN1N1gEvE1a = internal global |
| 9 | // CHECK: @_ZGVZN1N1gEvE1a = internal global |
| 10 | |
Sean Hunt | 3145525 | 2010-01-24 03:04:27 +0000 | [diff] [blame] | 11 | //CHECK: @pr5966_i = external global |
| 12 | //CHECK: @_ZL8pr5966_i = internal global |
| 13 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 14 | // CHECK: define zeroext i1 @_ZplRK1YRA100_P1X |
Douglas Gregor | 5f2bfd4 | 2009-02-13 00:10:09 +0000 | [diff] [blame] | 15 | bool operator+(const Y&, X* (&xs)[100]) { return false; } |
| 16 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 17 | // CHECK: define void @_Z1f1s |
Anders Carlsson | b1d947b | 2009-03-07 23:57:03 +0000 | [diff] [blame] | 18 | typedef struct { int a; } s; |
| 19 | void f(s) { } |
| 20 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 21 | // CHECK: define void @_Z1f1e |
Anders Carlsson | b1d947b | 2009-03-07 23:57:03 +0000 | [diff] [blame] | 22 | typedef enum { foo } e; |
| 23 | void f(e) { } |
| 24 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 25 | // CHECK: define void @_Z1f1u |
Anders Carlsson | b1d947b | 2009-03-07 23:57:03 +0000 | [diff] [blame] | 26 | typedef union { int a; } u; |
| 27 | void f(u) { } |
Anders Carlsson | 4843e58 | 2009-03-10 17:07:44 +0000 | [diff] [blame] | 28 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 29 | // CHECK: define void @_Z1f1x |
Anders Carlsson | 4843e58 | 2009-03-10 17:07:44 +0000 | [diff] [blame] | 30 | typedef struct { int a; } x,y; |
| 31 | void f(y) { } |
| 32 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 33 | // CHECK: define void @_Z1fv |
Anders Carlsson | c6c91bc | 2009-04-01 00:15:23 +0000 | [diff] [blame] | 34 | void f() { } |
Anders Carlsson | 984e068 | 2009-04-01 00:58:25 +0000 | [diff] [blame] | 35 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 36 | // CHECK: define void @_ZN1N1fEv |
Anders Carlsson | 984e068 | 2009-04-01 00:58:25 +0000 | [diff] [blame] | 37 | namespace N { void f() { } } |
| 38 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 39 | // CHECK: define void @_ZN1N1N1fEv |
Anders Carlsson | 984e068 | 2009-04-01 00:58:25 +0000 | [diff] [blame] | 40 | namespace N { namespace N { void f() { } } } |
Anders Carlsson | 91e20dd | 2009-04-02 05:55:18 +0000 | [diff] [blame] | 41 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 42 | // CHECK: define void @unmangled_function |
Anders Carlsson | 91e20dd | 2009-04-02 05:55:18 +0000 | [diff] [blame] | 43 | extern "C" { namespace N { void unmangled_function() { } } } |
| 44 | |
Anders Carlsson | 2928c21 | 2009-05-16 21:02:39 +0000 | [diff] [blame] | 45 | extern "C" { namespace N { int unmangled_variable = 10; } } |
Anders Carlsson | 91e20dd | 2009-04-02 05:55:18 +0000 | [diff] [blame] | 46 | |
Anders Carlsson | 329749c | 2009-04-02 16:05:20 +0000 | [diff] [blame] | 47 | namespace N { int i; } |
Anders Carlsson | 1b42c79 | 2009-04-02 16:24:45 +0000 | [diff] [blame] | 48 | |
Anders Carlsson | 1b42c79 | 2009-04-02 16:24:45 +0000 | [diff] [blame] | 49 | namespace N { int f(int, int) { static int b; return b; } } |
Anders Carlsson | 283a062 | 2009-04-13 18:03:33 +0000 | [diff] [blame] | 50 | |
Anders Carlsson | 283a062 | 2009-04-13 18:03:33 +0000 | [diff] [blame] | 51 | namespace N { int h(); void g() { static int a = h(); } } |
Chris Lattner | 2df9ced | 2009-04-30 02:43:43 +0000 | [diff] [blame] | 52 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 53 | // CHECK: define void @_Z1fno |
Chris Lattner | 2df9ced | 2009-04-30 02:43:43 +0000 | [diff] [blame] | 54 | void f(__int128_t, __uint128_t) { } |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 55 | |
| 56 | template <typename T> struct S1 {}; |
| 57 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 58 | // CHECK: define void @_Z1f2S1IiE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 59 | void f(S1<int>) {} |
| 60 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 61 | // CHECK: define void @_Z1f2S1IdE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 62 | void f(S1<double>) {} |
| 63 | |
| 64 | template <int N> struct S2 {}; |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 65 | // CHECK: define void @_Z1f2S2ILi100EE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 66 | void f(S2<100>) {} |
| 67 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 68 | // CHECK: define void @_Z1f2S2ILin100EE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 69 | void f(S2<-100>) {} |
| 70 | |
| 71 | template <bool B> struct S3 {}; |
| 72 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 73 | // CHECK: define void @_Z1f2S3ILb1EE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 74 | void f(S3<true>) {} |
| 75 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 76 | // CHECK: define void @_Z1f2S3ILb0EE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 77 | void f(S3<false>) {} |
| 78 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 79 | // CHECK: define void @_Z2f22S3ILb1EE |
Anders Carlsson | 7a0ba87 | 2009-05-15 16:09:15 +0000 | [diff] [blame] | 80 | void f2(S3<100>) {} |
Anders Carlsson | 0e65001 | 2009-05-17 17:41:20 +0000 | [diff] [blame] | 81 | |
| 82 | struct S; |
| 83 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 84 | // CHECK: define void @_Z1fM1SKFvvE |
Anders Carlsson | 0e65001 | 2009-05-17 17:41:20 +0000 | [diff] [blame] | 85 | void f(void (S::*)() const) {} |
| 86 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 87 | // CHECK: define void @_Z1fM1SFvvE |
Anders Carlsson | 0e65001 | 2009-05-17 17:41:20 +0000 | [diff] [blame] | 88 | void f(void (S::*)()) {} |
Anders Carlsson | cf85b93 | 2009-09-16 23:53:19 +0000 | [diff] [blame] | 89 | |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 90 | // CHECK: define void @_Z1fi |
Anders Carlsson | cf85b93 | 2009-09-16 23:53:19 +0000 | [diff] [blame] | 91 | void f(const int) { } |
| 92 | |
Anders Carlsson | 03c9d53 | 2009-09-17 04:02:31 +0000 | [diff] [blame] | 93 | template<typename T, typename U> void ft1(U u, T t) { } |
| 94 | |
| 95 | template<typename T> void ft2(T t, void (*)(T), void (*)(T)) { } |
Anders Carlsson | 9234b7f | 2009-09-17 03:46:43 +0000 | [diff] [blame] | 96 | |
Anders Carlsson | 7624f21 | 2009-09-18 02:42:01 +0000 | [diff] [blame] | 97 | template<typename T, typename U = S1<T> > struct S4 { }; |
| 98 | template<typename T> void ft3(S4<T>*) { } |
| 99 | |
Anders Carlsson | 7482e24 | 2009-09-18 04:29:09 +0000 | [diff] [blame] | 100 | namespace NS { |
| 101 | template<typename T> void ft1(T) { } |
Anders Carlsson | 7624f21 | 2009-09-18 02:42:01 +0000 | [diff] [blame] | 102 | } |
| 103 | |
Anders Carlsson | d553f8c | 2009-09-21 01:21:10 +0000 | [diff] [blame] | 104 | void g1() { |
Anders Carlsson | 03c9d53 | 2009-09-17 04:02:31 +0000 | [diff] [blame] | 105 | // CHECK: @_Z3ft1IidEvT0_T_ |
| 106 | ft1<int, double>(1, 0); |
| 107 | |
| 108 | // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_ |
| 109 | ft2<char>(1, 0, 0); |
Anders Carlsson | 7624f21 | 2009-09-18 02:42:01 +0000 | [diff] [blame] | 110 | |
| 111 | // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE |
| 112 | ft3<int>(0); |
Anders Carlsson | 7482e24 | 2009-09-18 04:29:09 +0000 | [diff] [blame] | 113 | |
| 114 | // CHECK: @_ZN2NS3ft1IiEEvT_ |
| 115 | NS::ft1<int>(1); |
Anders Carlsson | d58d6f7 | 2009-09-17 16:12:20 +0000 | [diff] [blame] | 116 | } |
Anders Carlsson | 7482e24 | 2009-09-18 04:29:09 +0000 | [diff] [blame] | 117 | |
Anders Carlsson | d553f8c | 2009-09-21 01:21:10 +0000 | [diff] [blame] | 118 | // Expressions |
| 119 | template<int I> struct S5 { }; |
| 120 | |
| 121 | template<int I> void ft4(S5<I>) { } |
| 122 | void g2() { |
| 123 | // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE |
| 124 | ft4(S5<10>()); |
| 125 | |
| 126 | // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE |
| 127 | ft4(S5<20>()); |
| 128 | } |
| 129 | |
Anders Carlsson | 7482e24 | 2009-09-18 04:29:09 +0000 | [diff] [blame] | 130 | extern "C++" { |
| 131 | // CHECK: @_Z1hv |
| 132 | void h() { } |
| 133 | } |
| 134 | |
Anders Carlsson | 5cc58c6 | 2009-09-22 17:23:30 +0000 | [diff] [blame] | 135 | // PR5019 |
| 136 | extern "C" { struct a { int b; }; } |
| 137 | |
| 138 | // CHECK: @_Z1fP1a |
| 139 | int f(struct a *x) { |
| 140 | return x->b; |
| 141 | } |
Anders Carlsson | add2882 | 2009-09-22 20:33:31 +0000 | [diff] [blame] | 142 | |
| 143 | // PR5017 |
| 144 | extern "C" { |
| 145 | struct Debug { |
Anders Carlsson | 8257d41 | 2009-12-22 06:36:32 +0000 | [diff] [blame] | 146 | const Debug& operator<< (unsigned a) const { return *this; } |
Anders Carlsson | add2882 | 2009-09-22 20:33:31 +0000 | [diff] [blame] | 147 | }; |
| 148 | Debug dbg; |
| 149 | // CHECK: @_ZNK5DebuglsEj |
| 150 | int main(void) { dbg << 32 ;} |
| 151 | } |
Anders Carlsson | ae35248 | 2009-09-26 02:26:02 +0000 | [diff] [blame] | 152 | |
| 153 | template<typename T> struct S6 { |
| 154 | typedef int B; |
| 155 | }; |
| 156 | |
| 157 | template<typename T> void ft5(typename S6<T>::B) { } |
| 158 | // CHECK: @_Z3ft5IiEvN2S6IT_E1BE |
| 159 | template void ft5<int>(int); |
Anders Carlsson | 1668f20 | 2009-09-26 20:13:56 +0000 | [diff] [blame] | 160 | |
| 161 | template<typename T> class A {}; |
| 162 | |
| 163 | namespace NS { |
| 164 | template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; } |
| 165 | } |
| 166 | |
Anders Carlsson | aeb8537 | 2009-09-26 22:18:22 +0000 | [diff] [blame] | 167 | // CHECK: @_ZN2NSeqIcEEbRK1AIT_ES5_ |
Anders Carlsson | 1668f20 | 2009-09-26 20:13:56 +0000 | [diff] [blame] | 168 | template bool NS::operator==(const ::A<char>&, const ::A<char>&); |
| 169 | |
| 170 | namespace std { |
| 171 | template<typename T> bool operator==(const A<T>&, const A<T>&) { return true; } |
| 172 | } |
| 173 | |
| 174 | // CHECK: @_ZSteqIcEbRK1AIT_ES4_ |
| 175 | template bool std::operator==(const ::A<char>&, const ::A<char>&); |
| 176 | |
Anders Carlsson | 0ccdf8d | 2009-09-27 00:38:53 +0000 | [diff] [blame] | 177 | struct S { |
| 178 | typedef int U; |
| 179 | }; |
| 180 | |
| 181 | template <typename T> typename T::U ft6(const T&) { return 0; } |
| 182 | |
| 183 | // CHECK: @_Z3ft6I1SENT_1UERKS1_ |
| 184 | template int ft6<S>(const S&); |
Anders Carlsson | 50755b0 | 2009-09-27 20:11:34 +0000 | [diff] [blame] | 185 | |
| 186 | template<typename> struct __is_scalar { |
| 187 | enum { __value = 1 }; |
| 188 | }; |
| 189 | |
| 190 | template<bool, typename> struct __enable_if { }; |
| 191 | |
| 192 | template<typename T> struct __enable_if<true, T> { |
| 193 | typedef T __type; |
| 194 | }; |
| 195 | |
| 196 | // PR5063 |
| 197 | template<typename T> typename __enable_if<__is_scalar<T>::__value, void>::__type ft7() { } |
| 198 | |
| 199 | // CHECK: @_Z3ft7IiEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv |
| 200 | template void ft7<int>(); |
| 201 | // CHECK: @_Z3ft7IPvEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv |
| 202 | template void ft7<void*>(); |
Anders Carlsson | b217c1b | 2009-10-06 21:58:01 +0000 | [diff] [blame] | 203 | |
| 204 | // PR5144 |
| 205 | extern "C" { |
| 206 | void extern_f(void); |
| 207 | }; |
| 208 | |
| 209 | // CHECK: @extern_f |
| 210 | void extern_f(void) { } |
| 211 | |
Anders Carlsson | c4355b6 | 2009-10-07 01:45:02 +0000 | [diff] [blame] | 212 | struct S7 { |
Anders Carlsson | 5c478cf | 2009-12-04 22:33:25 +0000 | [diff] [blame] | 213 | S7(); |
Anders Carlsson | c4355b6 | 2009-10-07 01:45:02 +0000 | [diff] [blame] | 214 | |
Anders Carlsson | 5c478cf | 2009-12-04 22:33:25 +0000 | [diff] [blame] | 215 | struct S { S(); }; |
Anders Carlsson | c4355b6 | 2009-10-07 01:45:02 +0000 | [diff] [blame] | 216 | struct { |
| 217 | S s; |
| 218 | } a; |
| 219 | }; |
| 220 | |
| 221 | // PR5139 |
| 222 | // CHECK: @_ZN2S7C1Ev |
| 223 | // CHECK: @_ZN2S7C2Ev |
| 224 | // CHECK: @"_ZN2S73$_0C1Ev" |
| 225 | S7::S7() {} |
| 226 | |
Anders Carlsson | a769408 | 2009-11-06 02:50:19 +0000 | [diff] [blame] | 227 | // PR5063 |
| 228 | template<typename T> typename __enable_if<(__is_scalar<T>::__value), void>::__type ft8() { } |
| 229 | // CHECK: @_Z3ft8IiEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv |
| 230 | template void ft8<int>(); |
| 231 | // CHECK: @_Z3ft8IPvEN11__enable_ifIXsr11__is_scalarIT_E7__valueEvE6__typeEv |
| 232 | template void ft8<void*>(); |
Anders Carlsson | e170ba7 | 2009-12-14 01:45:37 +0000 | [diff] [blame] | 233 | |
Anders Carlsson | 58040a5 | 2009-12-16 05:48:46 +0000 | [diff] [blame] | 234 | // PR5796 |
| 235 | namespace PR5796 { |
| 236 | template<typename> struct __is_scalar { |
| 237 | enum { __value = 0 }; |
| 238 | }; |
| 239 | |
| 240 | template<bool, typename> struct __enable_if {}; |
| 241 | template<typename T> struct __enable_if<true, T> { typedef T __type; }; |
| 242 | template<typename T> |
| 243 | |
| 244 | // CHECK: define linkonce_odr void @_ZN6PR57968__fill_aIiEENS_11__enable_ifIXntsrNS_11__is_scalarIT_EE7__valueEvE6__typeEv |
| 245 | typename __enable_if<!__is_scalar<T>::__value, void>::__type __fill_a() { }; |
| 246 | |
| 247 | void f() { __fill_a<int>(); } |
| 248 | } |
| 249 | |
Anders Carlsson | e170ba7 | 2009-12-14 01:45:37 +0000 | [diff] [blame] | 250 | namespace Expressions { |
| 251 | // Unary operators. |
| 252 | |
| 253 | // CHECK: define void @_ZN11Expressions2f1ILi1EEEvPAplngT_Li2E_i |
| 254 | template <int i> void f1(int (*)[(-i) + 2]) { }; |
| 255 | template void f1<1>(int (*)[1]); |
| 256 | |
| 257 | // CHECK: define void @_ZN11Expressions2f2ILi1EEEvPApsT__i |
| 258 | template <int i> void f2(int (*)[+i]) { }; |
| 259 | template void f2<1>(int (*)[1]); |
| 260 | |
| 261 | // Binary operators. |
| 262 | |
| 263 | // CHECK: define void @_ZN11Expressions2f3ILi1EEEvPAplT_T__i |
| 264 | template <int i> void f3(int (*)[i+i]) { }; |
| 265 | template void f3<1>(int (*)[2]); |
| 266 | |
| 267 | // CHECK: define void @_ZN11Expressions2f4ILi1EEEvPAplplLi2ET_T__i |
| 268 | template <int i> void f4(int (*)[2 + i+i]) { }; |
| 269 | template void f4<1>(int (*)[4]); |
| 270 | |
| 271 | // The ternary operator. |
| 272 | // CHECK: define void @_ZN11Expressions2f4ILb1EEEvPAquT_Li1ELi2E_i |
| 273 | template <bool b> void f4(int (*)[b ? 1 : 2]) { }; |
| 274 | template void f4<true>(int (*)[1]); |
Anders Carlsson | e170ba7 | 2009-12-14 01:45:37 +0000 | [diff] [blame] | 275 | } |
Anders Carlsson | 8257d41 | 2009-12-22 06:36:32 +0000 | [diff] [blame] | 276 | |
| 277 | struct Ops { |
| 278 | Ops& operator+(const Ops&); |
| 279 | Ops& operator-(const Ops&); |
| 280 | Ops& operator&(const Ops&); |
| 281 | Ops& operator*(const Ops&); |
| 282 | |
| 283 | void *v; |
| 284 | }; |
| 285 | |
| 286 | // CHECK: define %struct.Ops* @_ZN3OpsplERKS_ |
| 287 | Ops& Ops::operator+(const Ops&) { return *this; } |
| 288 | // CHECK: define %struct.Ops* @_ZN3OpsmiERKS_ |
| 289 | Ops& Ops::operator-(const Ops&) { return *this; } |
| 290 | // CHECK: define %struct.Ops* @_ZN3OpsanERKS_ |
| 291 | Ops& Ops::operator&(const Ops&) { return *this; } |
| 292 | // CHECK: define %struct.Ops* @_ZN3OpsmlERKS_ |
| 293 | Ops& Ops::operator*(const Ops&) { return *this; } |
| 294 | |
Anders Carlsson | 9e85c74 | 2009-12-23 19:30:55 +0000 | [diff] [blame] | 295 | // PR5861 |
| 296 | namespace PR5861 { |
| 297 | template<bool> class P; |
| 298 | template<> class P<true> {}; |
| 299 | |
| 300 | template<template <bool> class, bool> |
| 301 | struct Policy { }; |
| 302 | |
| 303 | template<typename T, typename = Policy<P, true> > class Alloc |
| 304 | { |
| 305 | T *allocate(int, const void*) { return 0; } |
| 306 | }; |
| 307 | |
| 308 | // CHECK: define i8* @_ZN6PR58615AllocIcNS_6PolicyINS_1PELb1EEEE8allocateEiPKv |
| 309 | template class Alloc<char>; |
| 310 | } |
Anders Carlsson | f28c687 | 2009-12-23 22:31:44 +0000 | [diff] [blame] | 311 | |
| 312 | // CHECK: define void @_Z1fU13block_pointerFiiiE |
Nuno Lopes | a9efbf0 | 2010-01-07 09:36:51 +0000 | [diff] [blame] | 313 | void f(int (^)(int, int)) { } |
| 314 | |
Sean Hunt | 3145525 | 2010-01-24 03:04:27 +0000 | [diff] [blame] | 315 | void pr5966_foo() { |
| 316 | extern int pr5966_i; |
| 317 | pr5966_i = 0; |
| 318 | } |
| 319 | |
| 320 | static int pr5966_i; |
| 321 | |
| 322 | void pr5966_bar() { |
| 323 | pr5966_i = 0; |
| 324 | } |
John McCall | 1dd7383 | 2010-02-04 01:42:13 +0000 | [diff] [blame] | 325 | |
| 326 | namespace test0 { |
| 327 | int ovl(int x); |
| 328 | char ovl(double x); |
| 329 | |
| 330 | template <class T> void f(T, char (&buffer)[sizeof(ovl(T()))]) {} |
| 331 | |
| 332 | void test0() { |
| 333 | char buffer[1]; |
| 334 | f(0.0, buffer); |
| 335 | } |
| 336 | // CHECK: define void @_ZN5test05test0Ev() |
| 337 | // CHECK: define linkonce_odr void @_ZN5test01fIdEEvT_RAszcl3ovlcvS1__EE_c( |
| 338 | |
| 339 | void test1() { |
| 340 | char buffer[sizeof(int)]; |
| 341 | f(1, buffer); |
| 342 | } |
| 343 | // CHECK: define void @_ZN5test05test1Ev() |
| 344 | // CHECK: define linkonce_odr void @_ZN5test01fIiEEvT_RAszcl3ovlcvS1__EE_c( |
| 345 | |
| 346 | template <class T> void g(char (&buffer)[sizeof(T() + 5.0f)]) {} |
| 347 | void test2() { |
| 348 | char buffer[sizeof(float)]; |
| 349 | g<float>(buffer); |
| 350 | } |
| 351 | // CHECK: define linkonce_odr void @_ZN5test01gIfEEvRAszplcvT__ELf40A00000E_c( |
| 352 | |
| 353 | template <class T> void h(char (&buffer)[sizeof(T() + 5.0)]) {} |
| 354 | void test3() { |
| 355 | char buffer[sizeof(double)]; |
| 356 | h<float>(buffer); |
| 357 | } |
| 358 | // CHECK: define linkonce_odr void @_ZN5test01hIfEEvRAszplcvT__ELd4014000000000000E_c( |
John McCall | 2f27bf8 | 2010-02-04 02:56:29 +0000 | [diff] [blame] | 359 | |
| 360 | template <class T> void j(char (&buffer)[sizeof(T().buffer)]) {} |
| 361 | struct A { double buffer[128]; }; |
| 362 | void test4() { |
| 363 | char buffer[1024]; |
| 364 | j<A>(buffer); |
| 365 | } |
| 366 | // CHECK: define linkonce_odr void @_ZN5test01jINS_1AEEEvRAszmecvT__E6buffer_c( |
John McCall | 1dd7383 | 2010-02-04 01:42:13 +0000 | [diff] [blame] | 367 | } |
Douglas Gregor | 32fb4e1 | 2010-02-05 20:45:00 +0000 | [diff] [blame^] | 368 | |
| 369 | namespace test1 { |
| 370 | template<typename T> struct X { }; |
| 371 | template<template<class> class Y, typename T> void f(Y<T>) { } |
| 372 | // CHECK: define void @_ZN5test11fINS_1XEiEEvT_IT0_E |
| 373 | template void f(X<int>); |
| 374 | } |