1 // RUN: %clang_cc1 %s -triple=armv7-unknown-unknown -emit-llvm -o - | FileCheck %s 2 // RUN: %clang_cc1 %s -triple=armv7-unknown-unknown -emit-llvm -o - | FileCheck -check-prefix=CHECK-LATE %s 3 4 // The 'a' variants ask for the v-table first. 5 // The 'b' variants ask for the v-table second. 6 // The 'c' variants ask for the v-table third. 7 // We do a separate CHECK-LATE pass because the RTTI defintion gets 8 // changed after the fact, which causes reordering of the globals. 9 10 // These are not separated into namespaces because the way that Sema 11 // currently reports namespaces to IR-generation (i.e., en masse for 12 // the entire namespace at once) subverts the ordering that we're 13 // trying to test. 14 15 namespace std { class type_info; } 16 extern void use(const std::type_info &rtti); 17 18 /*** Test0a ******************************************************************/ 19 20 struct Test0a { 21 Test0a(); 22 virtual inline void foo(); 23 virtual void bar(); 24 }; 25 26 // V-table should be defined externally. 27 Test0a::Test0a() { use(typeid(Test0a)); } 28 // CHECK: @_ZTV6Test0a = external unnamed_addr constant 29 // CHECK: @_ZTI6Test0a = external constant 30 31 // This is still not a key function. 32 void Test0a::foo() {} 33 34 /*** Test0b ******************************************************************/ 35 36 struct Test0b { 37 Test0b(); 38 virtual inline void foo(); 39 virtual void bar(); 40 }; 41 42 // This is still not a key function. 43 void Test0b::foo() {} 44 45 // V-table should be defined externally. 46 Test0b::Test0b() { use(typeid(Test0b)); } 47 // CHECK: @_ZTV6Test0b = external unnamed_addr constant 48 // CHECK: @_ZTI6Test0b = external constant 49 50 /*** Test1a ******************************************************************/ 51 52 struct Test1a { 53 Test1a(); 54 virtual void foo(); 55 virtual void bar(); 56 }; 57 58 // V-table should be defined externally. 59 Test1a::Test1a() { use(typeid(Test1a)); } 60 // CHECK: @_ZTV6Test1a = external unnamed_addr constant 61 // CHECK: @_ZTI6Test1a = external constant 62 63 // 'bar' becomes the key function when 'foo' is defined inline. 64 inline void Test1a::foo() {} 65 66 /*** Test1b ******************************************************************/ 67 68 struct Test1b { 69 Test1b(); 70 virtual void foo(); 71 virtual void bar(); 72 }; 73 74 // 'bar' becomes the key function when 'foo' is defined inline. 75 inline void Test1b::foo() {} 76 77 // V-table should be defined externally. 78 Test1b::Test1b() { use(typeid(Test1b)); } 79 // CHECK: @_ZTV6Test1b = external unnamed_addr constant 80 // CHECK: @_ZTI6Test1b = external constant 81 82 /*** Test2a ******************************************************************/ 83 84 struct Test2a { 85 Test2a(); 86 virtual void foo(); 87 virtual void bar(); 88 }; 89 90 // V-table should be defined with strong linkage. 91 Test2a::Test2a() { use(typeid(Test2a)); } 92 // CHECK: @_ZTV6Test2a = unnamed_addr constant 93 // CHECK-LATE: @_ZTS6Test2a = constant 94 // CHECK-LATE: @_ZTI6Test2a = unnamed_addr constant 95 96 // 'bar' becomes the key function when 'foo' is defined inline. 97 void Test2a::bar() {} 98 inline void Test2a::foo() {} 99 100 /*** Test2b ******************************************************************/ 101 102 struct Test2b { 103 Test2b(); 104 virtual void foo(); 105 virtual void bar(); 106 }; 107 108 // 'bar' becomes the key function when 'foo' is defined inline. 109 void Test2b::bar() {} 110 111 // V-table should be defined with strong linkage. 112 Test2b::Test2b() { use(typeid(Test2b)); } 113 // CHECK: @_ZTV6Test2b = unnamed_addr constant 114 // CHECK-LATE: @_ZTS6Test2b = constant 115 // CHECK-LATE: @_ZTI6Test2b = unnamed_addr constant 116 117 inline void Test2b::foo() {} 118 119 /*** Test2c ******************************************************************/ 120 121 struct Test2c { 122 Test2c(); 123 virtual void foo(); 124 virtual void bar(); 125 }; 126 127 // 'bar' becomes the key function when 'foo' is defined inline. 128 void Test2c::bar() {} 129 inline void Test2c::foo() {} 130 131 // V-table should be defined with strong linkage. 132 Test2c::Test2c() { use(typeid(Test2c)); } 133 // CHECK: @_ZTV6Test2c = unnamed_addr constant 134 // CHECK: @_ZTS6Test2c = constant 135 // CHECK: @_ZTI6Test2c = unnamed_addr constant 136 137 /*** Test3a ******************************************************************/ 138 139 struct Test3a { 140 Test3a(); 141 virtual void foo(); 142 virtual void bar(); 143 }; 144 145 // V-table should be defined with weak linkage. 146 Test3a::Test3a() { use(typeid(Test3a)); } 147 // CHECK: @_ZTV6Test3a = linkonce_odr unnamed_addr constant 148 // CHECK-LATE: @_ZTS6Test3a = linkonce_odr constant 149 // CHECK-LATE: @_ZTI6Test3a = linkonce_odr unnamed_addr constant 150 151 // There ceases to be a key function after these declarations. 152 inline void Test3a::bar() {} 153 inline void Test3a::foo() {} 154 155 /*** Test3b ******************************************************************/ 156 157 struct Test3b { 158 Test3b(); 159 virtual void foo(); 160 virtual void bar(); 161 }; 162 163 // There ceases to be a key function after these declarations. 164 inline void Test3b::bar() {} 165 166 // V-table should be defined with weak linkage. 167 Test3b::Test3b() { use(typeid(Test3b)); } 168 // CHECK: @_ZTV6Test3b = linkonce_odr unnamed_addr constant 169 // CHECK-LATE: @_ZTS6Test3b = linkonce_odr constant 170 // CHECK-LATE: @_ZTI6Test3b = linkonce_odr unnamed_addr constant 171 172 inline void Test3b::foo() {} 173 174 /*** Test3c ******************************************************************/ 175 176 struct Test3c { 177 Test3c(); 178 virtual void foo(); 179 virtual void bar(); 180 }; 181 182 // There ceases to be a key function after these declarations. 183 inline void Test3c::bar() {} 184 inline void Test3c::foo() {} 185 186 // V-table should be defined with weak linkage. 187 Test3c::Test3c() { use(typeid(Test3c)); } 188 // CHECK: @_ZTV6Test3c = linkonce_odr unnamed_addr constant 189 // CHECK: @_ZTS6Test3c = linkonce_odr constant 190 // CHECK: @_ZTI6Test3c = linkonce_odr unnamed_addr constant 191 192 /*** Test4a ******************************************************************/ 193 194 template <class T> struct Test4a { 195 Test4a(); 196 virtual void foo(); 197 virtual void bar(); 198 }; 199 200 // V-table should be defined with weak linkage. 201 template <> Test4a<int>::Test4a() { use(typeid(Test4a)); } 202 // CHECK: @_ZTV6Test4aIiE = linkonce_odr unnamed_addr constant 203 // CHECK: @_ZTS6Test4aIiE = linkonce_odr constant 204 // CHECK: @_ZTI6Test4aIiE = linkonce_odr unnamed_addr constant 205 206 // There ceases to be a key function after these declarations. 207 template <> inline void Test4a<int>::bar() {} 208 template <> inline void Test4a<int>::foo() {} 209 210 /*** Test4b ******************************************************************/ 211 212 template <class T> struct Test4b { 213 Test4b(); 214 virtual void foo(); 215 virtual void bar(); 216 }; 217 218 // There ceases to be a key function after these declarations. 219 template <> inline void Test4b<int>::bar() {} 220 221 // V-table should be defined with weak linkage. 222 template <> Test4b<int>::Test4b() { use(typeid(Test4b)); } 223 // CHECK: @_ZTV6Test4bIiE = linkonce_odr unnamed_addr constant 224 // CHECK: @_ZTS6Test4bIiE = linkonce_odr constant 225 // CHECK: @_ZTI6Test4bIiE = linkonce_odr unnamed_addr constant 226 227 template <> inline void Test4b<int>::foo() {} 228 229 /*** Test4c ******************************************************************/ 230 231 template <class T> struct Test4c { 232 Test4c(); 233 virtual void foo(); 234 virtual void bar(); 235 }; 236 237 // There ceases to be a key function after these declarations. 238 template <> inline void Test4c<int>::bar() {} 239 template <> inline void Test4c<int>::foo() {} 240 241 // V-table should be defined with weak linkage. 242 template <> Test4c<int>::Test4c() { use(typeid(Test4c)); } 243 // CHECK: @_ZTV6Test4cIiE = linkonce_odr unnamed_addr constant 244 // CHECK: @_ZTS6Test4cIiE = linkonce_odr constant 245 // CHECK: @_ZTI6Test4cIiE = linkonce_odr unnamed_addr constant 246 247 /*** Test5a ******************************************************************/ 248 249 template <class T> struct Test5a { 250 Test5a(); 251 virtual void foo(); 252 virtual void bar(); 253 }; 254 255 template <> inline void Test5a<int>::bar(); 256 template <> inline void Test5a<int>::foo(); 257 258 // V-table should be defined with weak linkage. 259 template <> Test5a<int>::Test5a() { use(typeid(Test5a)); } 260 // CHECK: @_ZTV6Test5aIiE = linkonce_odr unnamed_addr constant 261 // CHECK: @_ZTS6Test5aIiE = linkonce_odr constant 262 // CHECK: @_ZTI6Test5aIiE = linkonce_odr unnamed_addr constant 263 264 // There ceases to be a key function after these declarations. 265 template <> inline void Test5a<int>::bar() {} 266 template <> inline void Test5a<int>::foo() {} 267 268 /*** Test5b ******************************************************************/ 269 270 template <class T> struct Test5b { 271 Test5b(); 272 virtual void foo(); 273 virtual void bar(); 274 }; 275 276 // There ceases to be a key function after these declarations. 277 template <> inline void Test5a<int>::bar(); 278 template <> inline void Test5b<int>::bar() {} 279 280 // V-table should be defined with weak linkage. 281 template <> Test5b<int>::Test5b() { use(typeid(Test5b)); } 282 // CHECK: @_ZTV6Test5bIiE = linkonce_odr unnamed_addr constant 283 // CHECK: @_ZTS6Test5bIiE = linkonce_odr constant 284 // CHECK: @_ZTI6Test5bIiE = linkonce_odr unnamed_addr constant 285 286 template <> inline void Test5a<int>::foo(); 287 template <> inline void Test5b<int>::foo() {} 288 289 /*** Test5c ******************************************************************/ 290 291 template <class T> struct Test5c { 292 Test5c(); 293 virtual void foo(); 294 virtual void bar(); 295 }; 296 297 // There ceases to be a key function after these declarations. 298 template <> inline void Test5a<int>::bar(); 299 template <> inline void Test5a<int>::foo(); 300 template <> inline void Test5c<int>::bar() {} 301 template <> inline void Test5c<int>::foo() {} 302 303 // V-table should be defined with weak linkage. 304 template <> Test5c<int>::Test5c() { use(typeid(Test5c)); } 305 // CHECK: @_ZTV6Test5cIiE = linkonce_odr unnamed_addr constant 306 // CHECK: @_ZTS6Test5cIiE = linkonce_odr constant 307 // CHECK: @_ZTI6Test5cIiE = linkonce_odr unnamed_addr constant 308
