1 // I, Howard Hinnant, hereby place this code in the public domain. 2 3 // Test overload resolution among reference types 4 5 // { dg-do compile { target c++11 } } 6 // { dg-skip-if "packed attribute missing for struct one/three/five/seven" { "epiphany-*-*" } } 7 8 template <bool> struct sa; 9 template <> struct sa<true> {}; 10 11 struct one {long x[1];}; 12 struct two {long x[2];}; 13 struct three {long x[3];}; 14 struct four {long x[4];}; 15 struct five {long x[5];}; 16 struct six {long x[6];}; 17 struct seven {long x[7];}; 18 struct eight {long x[8];}; 19 20 struct A 21 { 22 A(); 23 A(const volatile A&&); 24 }; 25 26 A source(); 27 const A c_source(); 28 volatile A v_source(); // { dg-warning "deprecated" "" { target c++2a } } 29 const volatile A cv_source(); // { dg-warning "deprecated" "" { target c++2a } } 30 31 // 5 at a time 32 33 one sink_5_12345( A&); 34 two sink_5_12345(const A&); 35 three sink_5_12345(volatile A&); 36 four sink_5_12345(const volatile A&); 37 five sink_5_12345( A&&); 38 39 int test5_12345() 40 { 41 A a; 42 const A ca; 43 volatile A va; 44 const volatile A cva; 45 sa<sizeof(sink_5_12345(a)) == 1* sizeof(long)> t1; 46 sa<sizeof(sink_5_12345(ca)) == 2* sizeof(long)> t2; 47 sa<sizeof(sink_5_12345(va)) == 3* sizeof(long)> t3; 48 sa<sizeof(sink_5_12345(cva)) == 4* sizeof(long)> t4; 49 sa<sizeof(sink_5_12345(source())) == 5* sizeof(long)> t5; 50 sa<sizeof(sink_5_12345(c_source())) == 2* sizeof(long)> t6; 51 return 0; 52 } 53 54 one sink_5_12346( A&); 55 two sink_5_12346(const A&); 56 three sink_5_12346(volatile A&); 57 four sink_5_12346(const volatile A&); 58 six sink_5_12346(const A&&); 59 60 int test5_12346() 61 { 62 A a; 63 const A ca; 64 volatile A va; 65 const volatile A cva; 66 sa<sizeof(sink_5_12346(a)) == 1* sizeof(long)> t1; 67 sa<sizeof(sink_5_12346(ca)) == 2* sizeof(long)> t2; 68 sa<sizeof(sink_5_12346(va)) == 3* sizeof(long)> t3; 69 sa<sizeof(sink_5_12346(cva)) == 4* sizeof(long)> t4; 70 sa<sizeof(sink_5_12346(source())) == 6* sizeof(long)> t5; 71 sa<sizeof(sink_5_12346(c_source())) == 6* sizeof(long)> t6; 72 return 0; 73 } 74 75 one sink_5_12347( A&); 76 two sink_5_12347(const A&); 77 three sink_5_12347(volatile A&); 78 four sink_5_12347(const volatile A&); 79 seven sink_5_12347(volatile A&&); 80 81 int test5_12347() 82 { 83 A a; 84 const A ca; 85 volatile A va; 86 const volatile A cva; 87 sa<sizeof(sink_5_12347(a)) == 1* sizeof(long)> t1; 88 sa<sizeof(sink_5_12347(ca)) == 2* sizeof(long)> t2; 89 sa<sizeof(sink_5_12347(va)) == 3* sizeof(long)> t3; 90 sa<sizeof(sink_5_12347(cva)) == 4* sizeof(long)> t4; 91 sa<sizeof(sink_5_12347(source())) == 7* sizeof(long)> t5; 92 sa<sizeof(sink_5_12347(c_source())) == 2* sizeof(long)> t6; 93 sa<sizeof(sink_5_12347(v_source())) == 7* sizeof(long)> t7; 94 return 0; 95 } 96 97 one sink_5_12348( A&); 98 two sink_5_12348(const A&); 99 three sink_5_12348(volatile A&); 100 four sink_5_12348(const volatile A&); 101 eight sink_5_12348(const volatile A&&); 102 103 int test5_12348() 104 { 105 A a; 106 const A ca; 107 volatile A va; 108 const volatile A cva; 109 sa<sizeof(sink_5_12348(a)) == 1* sizeof(long)> t1; 110 sa<sizeof(sink_5_12348(ca)) == 2* sizeof(long)> t2; 111 sa<sizeof(sink_5_12348(va)) == 3* sizeof(long)> t3; 112 sa<sizeof(sink_5_12348(cva)) == 4* sizeof(long)> t4; 113 sa<sizeof(sink_5_12348(source())) == 8* sizeof(long)> t5; 114 sa<sizeof(sink_5_12348(c_source())) == 8* sizeof(long)> t6; 115 sa<sizeof(sink_5_12348(v_source())) == 8* sizeof(long)> t7; 116 sa<sizeof(sink_5_12348(cv_source())) == 8* sizeof(long)> t8; 117 return 0; 118 } 119 120 one sink_5_12356( A&); 121 two sink_5_12356(const A&); 122 three sink_5_12356(volatile A&); 123 five sink_5_12356( A&&); 124 six sink_5_12356(const A&&); 125 126 int test5_12356() 127 { 128 A a; 129 const A ca; 130 volatile A va; 131 const volatile A cva; 132 sa<sizeof(sink_5_12356(a)) == 1* sizeof(long)> t1; 133 sa<sizeof(sink_5_12356(ca)) == 2* sizeof(long)> t2; 134 sa<sizeof(sink_5_12356(va)) == 3* sizeof(long)> t3; 135 sa<sizeof(sink_5_12356(source())) == 5* sizeof(long)> t5; 136 sa<sizeof(sink_5_12356(c_source())) == 6* sizeof(long)> t6; 137 return 0; 138 } 139 140 one sink_5_12357( A&); 141 two sink_5_12357(const A&); 142 three sink_5_12357(volatile A&); 143 five sink_5_12357( A&&); 144 seven sink_5_12357(volatile A&&); 145 146 int test5_12357() 147 { 148 A a; 149 const A ca; 150 volatile A va; 151 const volatile A cva; 152 sa<sizeof(sink_5_12357(a)) == 1* sizeof(long)> t1; 153 sa<sizeof(sink_5_12357(ca)) == 2* sizeof(long)> t2; 154 sa<sizeof(sink_5_12357(va)) == 3* sizeof(long)> t3; 155 sa<sizeof(sink_5_12357(source())) == 5* sizeof(long)> t5; 156 sa<sizeof(sink_5_12357(c_source())) == 2* sizeof(long)> t6; 157 sa<sizeof(sink_5_12357(v_source())) == 7* sizeof(long)> t7; 158 return 0; 159 } 160 161 one sink_5_12358( A&); 162 two sink_5_12358(const A&); 163 three sink_5_12358(volatile A&); 164 five sink_5_12358( A&&); 165 eight sink_5_12358(const volatile A&&); 166 167 int test5_12358() 168 { 169 A a; 170 const A ca; 171 volatile A va; 172 const volatile A cva; 173 sa<sizeof(sink_5_12358(a)) == 1* sizeof(long)> t1; 174 sa<sizeof(sink_5_12358(ca)) == 2* sizeof(long)> t2; 175 sa<sizeof(sink_5_12358(va)) == 3* sizeof(long)> t3; 176 sa<sizeof(sink_5_12358(source())) == 5* sizeof(long)> t5; 177 sa<sizeof(sink_5_12358(c_source())) == 8* sizeof(long)> t6; 178 sa<sizeof(sink_5_12358(v_source())) == 8* sizeof(long)> t7; 179 sa<sizeof(sink_5_12358(cv_source())) == 8* sizeof(long)> t8; 180 return 0; 181 } 182 183 one sink_5_12367( A&); 184 two sink_5_12367(const A&); 185 three sink_5_12367(volatile A&); 186 six sink_5_12367(const A&&); 187 seven sink_5_12367(volatile A&&); 188 189 int test5_12367() 190 { 191 A a; 192 const A ca; 193 volatile A va; 194 const volatile A cva; 195 sa<sizeof(sink_5_12367(a)) == 1* sizeof(long)> t1; 196 sa<sizeof(sink_5_12367(ca)) == 2* sizeof(long)> t2; 197 sa<sizeof(sink_5_12367(va)) == 3* sizeof(long)> t3; 198 sa<sizeof(sink_5_12367(c_source())) == 6* sizeof(long)> t6; 199 sa<sizeof(sink_5_12367(v_source())) == 7* sizeof(long)> t7; 200 return 0; 201 } 202 203 one sink_5_12368( A&); 204 two sink_5_12368(const A&); 205 three sink_5_12368(volatile A&); 206 six sink_5_12368(const A&&); 207 eight sink_5_12368(const volatile A&&); 208 209 int test5_12368() 210 { 211 A a; 212 const A ca; 213 volatile A va; 214 const volatile A cva; 215 sa<sizeof(sink_5_12368(a)) == 1* sizeof(long)> t1; 216 sa<sizeof(sink_5_12368(ca)) == 2* sizeof(long)> t2; 217 sa<sizeof(sink_5_12368(va)) == 3* sizeof(long)> t3; 218 sa<sizeof(sink_5_12368(source())) == 6* sizeof(long)> t5; 219 sa<sizeof(sink_5_12368(c_source())) == 6* sizeof(long)> t6; 220 sa<sizeof(sink_5_12368(v_source())) == 8* sizeof(long)> t7; 221 sa<sizeof(sink_5_12368(cv_source())) == 8* sizeof(long)> t8; 222 return 0; 223 } 224 225 one sink_5_12378( A&); 226 two sink_5_12378(const A&); 227 three sink_5_12378(volatile A&); 228 seven sink_5_12378(volatile A&&); 229 eight sink_5_12378(const volatile A&&); 230 231 int test5_12378() 232 { 233 A a; 234 const A ca; 235 volatile A va; 236 const volatile A cva; 237 sa<sizeof(sink_5_12378(a)) == 1* sizeof(long)> t1; 238 sa<sizeof(sink_5_12378(ca)) == 2* sizeof(long)> t2; 239 sa<sizeof(sink_5_12378(va)) == 3* sizeof(long)> t3; 240 sa<sizeof(sink_5_12378(source())) == 7* sizeof(long)> t5; 241 sa<sizeof(sink_5_12378(c_source())) == 8* sizeof(long)> t6; 242 sa<sizeof(sink_5_12378(v_source())) == 7* sizeof(long)> t7; 243 sa<sizeof(sink_5_12378(cv_source())) == 8* sizeof(long)> t8; 244 return 0; 245 } 246 247 one sink_5_12456( A&); 248 two sink_5_12456(const A&); 249 four sink_5_12456(const volatile A&); 250 five sink_5_12456( A&&); 251 six sink_5_12456(const A&&); 252 253 int test5_12456() 254 { 255 A a; 256 const A ca; 257 volatile A va; 258 const volatile A cva; 259 sa<sizeof(sink_5_12456(a)) == 1* sizeof(long)> t1; 260 sa<sizeof(sink_5_12456(ca)) == 2* sizeof(long)> t2; 261 sa<sizeof(sink_5_12456(va)) == 4* sizeof(long)> t3; 262 sa<sizeof(sink_5_12456(cva)) == 4* sizeof(long)> t4; 263 sa<sizeof(sink_5_12456(source())) == 5* sizeof(long)> t5; 264 sa<sizeof(sink_5_12456(c_source())) == 6* sizeof(long)> t6; 265 return 0; 266 } 267 268 one sink_5_12457( A&); 269 two sink_5_12457(const A&); 270 four sink_5_12457(const volatile A&); 271 five sink_5_12457( A&&); 272 seven sink_5_12457(volatile A&&); 273 274 int test5_12457() 275 { 276 A a; 277 const A ca; 278 volatile A va; 279 const volatile A cva; 280 sa<sizeof(sink_5_12457(a)) == 1* sizeof(long)> t1; 281 sa<sizeof(sink_5_12457(ca)) == 2* sizeof(long)> t2; 282 sa<sizeof(sink_5_12457(va)) == 4* sizeof(long)> t3; 283 sa<sizeof(sink_5_12457(cva)) == 4* sizeof(long)> t4; 284 sa<sizeof(sink_5_12457(source())) == 5* sizeof(long)> t5; 285 sa<sizeof(sink_5_12457(c_source())) == 2* sizeof(long)> t6; 286 sa<sizeof(sink_5_12457(v_source())) == 7* sizeof(long)> t7; 287 return 0; 288 } 289 290 one sink_5_12458( A&); 291 two sink_5_12458(const A&); 292 four sink_5_12458(const volatile A&); 293 five sink_5_12458( A&&); 294 eight sink_5_12458(const volatile A&&); 295 296 int test5_12458() 297 { 298 A a; 299 const A ca; 300 volatile A va; 301 const volatile A cva; 302 sa<sizeof(sink_5_12458(a)) == 1* sizeof(long)> t1; 303 sa<sizeof(sink_5_12458(ca)) == 2* sizeof(long)> t2; 304 sa<sizeof(sink_5_12458(va)) == 4* sizeof(long)> t3; 305 sa<sizeof(sink_5_12458(cva)) == 4* sizeof(long)> t4; 306 sa<sizeof(sink_5_12458(source())) == 5* sizeof(long)> t5; 307 sa<sizeof(sink_5_12458(c_source())) == 8* sizeof(long)> t6; 308 sa<sizeof(sink_5_12458(v_source())) == 8* sizeof(long)> t7; 309 sa<sizeof(sink_5_12458(cv_source())) == 8* sizeof(long)> t8; 310 return 0; 311 } 312 313 one sink_5_12467( A&); 314 two sink_5_12467(const A&); 315 four sink_5_12467(const volatile A&); 316 six sink_5_12467(const A&&); 317 seven sink_5_12467(volatile A&&); 318 319 int test5_12467() 320 { 321 A a; 322 const A ca; 323 volatile A va; 324 const volatile A cva; 325 sa<sizeof(sink_5_12467(a)) == 1* sizeof(long)> t1; 326 sa<sizeof(sink_5_12467(ca)) == 2* sizeof(long)> t2; 327 sa<sizeof(sink_5_12467(va)) == 4* sizeof(long)> t3; 328 sa<sizeof(sink_5_12467(cva)) == 4* sizeof(long)> t4; 329 sa<sizeof(sink_5_12467(c_source())) == 6* sizeof(long)> t6; 330 sa<sizeof(sink_5_12467(v_source())) == 7* sizeof(long)> t7; 331 return 0; 332 } 333 334 one sink_5_12468( A&); 335 two sink_5_12468(const A&); 336 four sink_5_12468(const volatile A&); 337 six sink_5_12468(const A&&); 338 eight sink_5_12468(const volatile A&&); 339 340 int test5_12468() 341 { 342 A a; 343 const A ca; 344 volatile A va; 345 const volatile A cva; 346 sa<sizeof(sink_5_12468(a)) == 1* sizeof(long)> t1; 347 sa<sizeof(sink_5_12468(ca)) == 2* sizeof(long)> t2; 348 sa<sizeof(sink_5_12468(va)) == 4* sizeof(long)> t3; 349 sa<sizeof(sink_5_12468(cva)) == 4* sizeof(long)> t4; 350 sa<sizeof(sink_5_12468(source())) == 6* sizeof(long)> t5; 351 sa<sizeof(sink_5_12468(c_source())) == 6* sizeof(long)> t6; 352 sa<sizeof(sink_5_12468(v_source())) == 8* sizeof(long)> t7; 353 sa<sizeof(sink_5_12468(cv_source())) == 8* sizeof(long)> t8; 354 return 0; 355 } 356 357 one sink_5_12478( A&); 358 two sink_5_12478(const A&); 359 four sink_5_12478(const volatile A&); 360 seven sink_5_12478(volatile A&&); 361 eight sink_5_12478(const volatile A&&); 362 363 int test5_12478() 364 { 365 A a; 366 const A ca; 367 volatile A va; 368 const volatile A cva; 369 sa<sizeof(sink_5_12478(a)) == 1* sizeof(long)> t1; 370 sa<sizeof(sink_5_12478(ca)) == 2* sizeof(long)> t2; 371 sa<sizeof(sink_5_12478(va)) == 4* sizeof(long)> t3; 372 sa<sizeof(sink_5_12478(cva)) == 4* sizeof(long)> t4; 373 sa<sizeof(sink_5_12478(source())) == 7* sizeof(long)> t5; 374 sa<sizeof(sink_5_12478(c_source())) == 8* sizeof(long)> t6; 375 sa<sizeof(sink_5_12478(v_source())) == 7* sizeof(long)> t7; 376 sa<sizeof(sink_5_12478(cv_source())) == 8* sizeof(long)> t8; 377 return 0; 378 } 379 380 one sink_5_12567( A&); 381 two sink_5_12567(const A&); 382 five sink_5_12567( A&&); 383 six sink_5_12567(const A&&); 384 seven sink_5_12567(volatile A&&); 385 386 int test5_12567() 387 { 388 A a; 389 const A ca; 390 volatile A va; 391 const volatile A cva; 392 sa<sizeof(sink_5_12567(a)) == 1* sizeof(long)> t1; 393 sa<sizeof(sink_5_12567(ca)) == 2* sizeof(long)> t2; 394 sa<sizeof(sink_5_12567(source())) == 5* sizeof(long)> t5; 395 sa<sizeof(sink_5_12567(c_source())) == 6* sizeof(long)> t6; 396 sa<sizeof(sink_5_12567(v_source())) == 7* sizeof(long)> t7; 397 return 0; 398 } 399 400 one sink_5_12568( A&); 401 two sink_5_12568(const A&); 402 five sink_5_12568( A&&); 403 six sink_5_12568(const A&&); 404 eight sink_5_12568(const volatile A&&); 405 406 int test5_12568() 407 { 408 A a; 409 const A ca; 410 volatile A va; 411 const volatile A cva; 412 sa<sizeof(sink_5_12568(a)) == 1* sizeof(long)> t1; 413 sa<sizeof(sink_5_12568(ca)) == 2* sizeof(long)> t2; 414 sa<sizeof(sink_5_12568(source())) == 5* sizeof(long)> t5; 415 sa<sizeof(sink_5_12568(c_source())) == 6* sizeof(long)> t6; 416 sa<sizeof(sink_5_12568(v_source())) == 8* sizeof(long)> t7; 417 sa<sizeof(sink_5_12568(cv_source())) == 8* sizeof(long)> t8; 418 return 0; 419 } 420 421 one sink_5_12578( A&); 422 two sink_5_12578(const A&); 423 five sink_5_12578( A&&); 424 seven sink_5_12578(volatile A&&); 425 eight sink_5_12578(const volatile A&&); 426 427 int test5_12578() 428 { 429 A a; 430 const A ca; 431 volatile A va; 432 const volatile A cva; 433 sa<sizeof(sink_5_12578(a)) == 1* sizeof(long)> t1; 434 sa<sizeof(sink_5_12578(ca)) == 2* sizeof(long)> t2; 435 sa<sizeof(sink_5_12578(source())) == 5* sizeof(long)> t5; 436 sa<sizeof(sink_5_12578(c_source())) == 8* sizeof(long)> t6; 437 sa<sizeof(sink_5_12578(v_source())) == 7* sizeof(long)> t7; 438 sa<sizeof(sink_5_12578(cv_source())) == 8* sizeof(long)> t8; 439 return 0; 440 } 441 442 one sink_5_12678( A&); 443 two sink_5_12678(const A&); 444 six sink_5_12678(const A&&); 445 seven sink_5_12678(volatile A&&); 446 eight sink_5_12678(const volatile A&&); 447 448 int test5_12678() 449 { 450 A a; 451 const A ca; 452 volatile A va; 453 const volatile A cva; 454 sa<sizeof(sink_5_12678(a)) == 1* sizeof(long)> t1; 455 sa<sizeof(sink_5_12678(ca)) == 2* sizeof(long)> t2; 456 sa<sizeof(sink_5_12678(c_source())) == 6* sizeof(long)> t6; 457 sa<sizeof(sink_5_12678(v_source())) == 7* sizeof(long)> t7; 458 sa<sizeof(sink_5_12678(cv_source())) == 8* sizeof(long)> t8; 459 return 0; 460 } 461 462 one sink_5_13456( A&); 463 three sink_5_13456(volatile A&); 464 four sink_5_13456(const volatile A&); 465 five sink_5_13456( A&&); 466 six sink_5_13456(const A&&); 467 468 int test5_13456() 469 { 470 A a; 471 const A ca; 472 volatile A va; 473 const volatile A cva; 474 sa<sizeof(sink_5_13456(a)) == 1* sizeof(long)> t1; 475 sa<sizeof(sink_5_13456(ca)) == 4* sizeof(long)> t2; 476 sa<sizeof(sink_5_13456(va)) == 3* sizeof(long)> t3; 477 sa<sizeof(sink_5_13456(cva)) == 4* sizeof(long)> t4; 478 sa<sizeof(sink_5_13456(source())) == 5* sizeof(long)> t5; 479 sa<sizeof(sink_5_13456(c_source())) == 6* sizeof(long)> t6; 480 return 0; 481 } 482 483 one sink_5_13457( A&); 484 three sink_5_13457(volatile A&); 485 four sink_5_13457(const volatile A&); 486 five sink_5_13457( A&&); 487 seven sink_5_13457(volatile A&&); 488 489 int test5_13457() 490 { 491 A a; 492 const A ca; 493 volatile A va; 494 const volatile A cva; 495 sa<sizeof(sink_5_13457(a)) == 1* sizeof(long)> t1; 496 sa<sizeof(sink_5_13457(ca)) == 4* sizeof(long)> t2; 497 sa<sizeof(sink_5_13457(va)) == 3* sizeof(long)> t3; 498 sa<sizeof(sink_5_13457(cva)) == 4* sizeof(long)> t4; 499 sa<sizeof(sink_5_13457(source())) == 5* sizeof(long)> t5; 500 sa<sizeof(sink_5_13457(v_source())) == 7* sizeof(long)> t7; 501 return 0; 502 } 503 504 one sink_5_13458( A&); 505 three sink_5_13458(volatile A&); 506 four sink_5_13458(const volatile A&); 507 five sink_5_13458( A&&); 508 eight sink_5_13458(const volatile A&&); 509 510 int test5_13458() 511 { 512 A a; 513 const A ca; 514 volatile A va; 515 const volatile A cva; 516 sa<sizeof(sink_5_13458(a)) == 1* sizeof(long)> t1; 517 sa<sizeof(sink_5_13458(ca)) == 4* sizeof(long)> t2; 518 sa<sizeof(sink_5_13458(va)) == 3* sizeof(long)> t3; 519 sa<sizeof(sink_5_13458(cva)) == 4* sizeof(long)> t4; 520 sa<sizeof(sink_5_13458(source())) == 5* sizeof(long)> t5; 521 sa<sizeof(sink_5_13458(c_source())) == 8* sizeof(long)> t6; 522 sa<sizeof(sink_5_13458(v_source())) == 8* sizeof(long)> t7; 523 sa<sizeof(sink_5_13458(cv_source())) == 8* sizeof(long)> t8; 524 return 0; 525 } 526 527 one sink_5_13467( A&); 528 three sink_5_13467(volatile A&); 529 four sink_5_13467(const volatile A&); 530 six sink_5_13467(const A&&); 531 seven sink_5_13467(volatile A&&); 532 533 int test5_13467() 534 { 535 A a; 536 const A ca; 537 volatile A va; 538 const volatile A cva; 539 sa<sizeof(sink_5_13467(a)) == 1* sizeof(long)> t1; 540 sa<sizeof(sink_5_13467(ca)) == 4* sizeof(long)> t2; 541 sa<sizeof(sink_5_13467(va)) == 3* sizeof(long)> t3; 542 sa<sizeof(sink_5_13467(cva)) == 4* sizeof(long)> t4; 543 sa<sizeof(sink_5_13467(c_source())) == 6* sizeof(long)> t6; 544 sa<sizeof(sink_5_13467(v_source())) == 7* sizeof(long)> t7; 545 return 0; 546 } 547 548 one sink_5_13468( A&); 549 three sink_5_13468(volatile A&); 550 four sink_5_13468(const volatile A&); 551 six sink_5_13468(const A&&); 552 eight sink_5_13468(const volatile A&&); 553 554 int test5_13468() 555 { 556 A a; 557 const A ca; 558 volatile A va; 559 const volatile A cva; 560 sa<sizeof(sink_5_13468(a)) == 1* sizeof(long)> t1; 561 sa<sizeof(sink_5_13468(ca)) == 4* sizeof(long)> t2; 562 sa<sizeof(sink_5_13468(va)) == 3* sizeof(long)> t3; 563 sa<sizeof(sink_5_13468(cva)) == 4* sizeof(long)> t4; 564 sa<sizeof(sink_5_13468(source())) == 6* sizeof(long)> t5; 565 sa<sizeof(sink_5_13468(c_source())) == 6* sizeof(long)> t6; 566 sa<sizeof(sink_5_13468(v_source())) == 8* sizeof(long)> t7; 567 sa<sizeof(sink_5_13468(cv_source())) == 8* sizeof(long)> t8; 568 return 0; 569 } 570 571 one sink_5_13478( A&); 572 three sink_5_13478(volatile A&); 573 four sink_5_13478(const volatile A&); 574 seven sink_5_13478(volatile A&&); 575 eight sink_5_13478(const volatile A&&); 576 577 int test5_13478() 578 { 579 A a; 580 const A ca; 581 volatile A va; 582 const volatile A cva; 583 sa<sizeof(sink_5_13478(a)) == 1* sizeof(long)> t1; 584 sa<sizeof(sink_5_13478(ca)) == 4* sizeof(long)> t2; 585 sa<sizeof(sink_5_13478(va)) == 3* sizeof(long)> t3; 586 sa<sizeof(sink_5_13478(cva)) == 4* sizeof(long)> t4; 587 sa<sizeof(sink_5_13478(source())) == 7* sizeof(long)> t5; 588 sa<sizeof(sink_5_13478(c_source())) == 8* sizeof(long)> t6; 589 sa<sizeof(sink_5_13478(v_source())) == 7* sizeof(long)> t7; 590 sa<sizeof(sink_5_13478(cv_source())) == 8* sizeof(long)> t8; 591 return 0; 592 } 593 594 one sink_5_13567( A&); 595 three sink_5_13567(volatile A&); 596 five sink_5_13567( A&&); 597 six sink_5_13567(const A&&); 598 seven sink_5_13567(volatile A&&); 599 600 int test5_13567() 601 { 602 A a; 603 const A ca; 604 volatile A va; 605 const volatile A cva; 606 sa<sizeof(sink_5_13567(a)) == 1* sizeof(long)> t1; 607 sa<sizeof(sink_5_13567(va)) == 3* sizeof(long)> t3; 608 sa<sizeof(sink_5_13567(source())) == 5* sizeof(long)> t5; 609 sa<sizeof(sink_5_13567(c_source())) == 6* sizeof(long)> t6; 610 sa<sizeof(sink_5_13567(v_source())) == 7* sizeof(long)> t7; 611 return 0; 612 } 613 614 one sink_5_13568( A&); 615 three sink_5_13568(volatile A&); 616 five sink_5_13568( A&&); 617 six sink_5_13568(const A&&); 618 eight sink_5_13568(const volatile A&&); 619 620 int test5_13568() 621 { 622 A a; 623 const A ca; 624 volatile A va; 625 const volatile A cva; 626 sa<sizeof(sink_5_13568(a)) == 1* sizeof(long)> t1; 627 sa<sizeof(sink_5_13568(va)) == 3* sizeof(long)> t3; 628 sa<sizeof(sink_5_13568(source())) == 5* sizeof(long)> t5; 629 sa<sizeof(sink_5_13568(c_source())) == 6* sizeof(long)> t6; 630 sa<sizeof(sink_5_13568(v_source())) == 8* sizeof(long)> t7; 631 sa<sizeof(sink_5_13568(cv_source())) == 8* sizeof(long)> t8; 632 return 0; 633 } 634 635 one sink_5_13578( A&); 636 three sink_5_13578(volatile A&); 637 five sink_5_13578( A&&); 638 seven sink_5_13578(volatile A&&); 639 eight sink_5_13578(const volatile A&&); 640 641 int test5_13578() 642 { 643 A a; 644 const A ca; 645 volatile A va; 646 const volatile A cva; 647 sa<sizeof(sink_5_13578(a)) == 1* sizeof(long)> t1; 648 sa<sizeof(sink_5_13578(va)) == 3* sizeof(long)> t3; 649 sa<sizeof(sink_5_13578(source())) == 5* sizeof(long)> t5; 650 sa<sizeof(sink_5_13578(c_source())) == 8* sizeof(long)> t6; 651 sa<sizeof(sink_5_13578(v_source())) == 7* sizeof(long)> t7; 652 sa<sizeof(sink_5_13578(cv_source())) == 8* sizeof(long)> t8; 653 return 0; 654 } 655 656 one sink_5_13678( A&); 657 three sink_5_13678(volatile A&); 658 six sink_5_13678(const A&&); 659 seven sink_5_13678(volatile A&&); 660 eight sink_5_13678(const volatile A&&); 661 662 int test5_13678() 663 { 664 A a; 665 const A ca; 666 volatile A va; 667 const volatile A cva; 668 sa<sizeof(sink_5_13678(a)) == 1* sizeof(long)> t1; 669 sa<sizeof(sink_5_13678(va)) == 3* sizeof(long)> t3; 670 sa<sizeof(sink_5_13678(c_source())) == 6* sizeof(long)> t6; 671 sa<sizeof(sink_5_13678(v_source())) == 7* sizeof(long)> t7; 672 sa<sizeof(sink_5_13678(cv_source())) == 8* sizeof(long)> t8; 673 return 0; 674 } 675 676 one sink_5_14567( A&); 677 four sink_5_14567(const volatile A&); 678 five sink_5_14567( A&&); 679 six sink_5_14567(const A&&); 680 seven sink_5_14567(volatile A&&); 681 682 int test5_14567() 683 { 684 A a; 685 const A ca; 686 volatile A va; 687 const volatile A cva; 688 sa<sizeof(sink_5_14567(a)) == 1* sizeof(long)> t1; 689 sa<sizeof(sink_5_14567(ca)) == 4* sizeof(long)> t2; 690 sa<sizeof(sink_5_14567(va)) == 4* sizeof(long)> t3; 691 sa<sizeof(sink_5_14567(cva)) == 4* sizeof(long)> t4; 692 sa<sizeof(sink_5_14567(source())) == 5* sizeof(long)> t5; 693 sa<sizeof(sink_5_14567(c_source())) == 6* sizeof(long)> t6; 694 sa<sizeof(sink_5_14567(v_source())) == 7* sizeof(long)> t7; 695 return 0; 696 } 697 698 one sink_5_14568( A&); 699 four sink_5_14568(const volatile A&); 700 five sink_5_14568( A&&); 701 six sink_5_14568(const A&&); 702 eight sink_5_14568(const volatile A&&); 703 704 int test5_14568() 705 { 706 A a; 707 const A ca; 708 volatile A va; 709 const volatile A cva; 710 sa<sizeof(sink_5_14568(a)) == 1* sizeof(long)> t1; 711 sa<sizeof(sink_5_14568(ca)) == 4* sizeof(long)> t2; 712 sa<sizeof(sink_5_14568(va)) == 4* sizeof(long)> t3; 713 sa<sizeof(sink_5_14568(cva)) == 4* sizeof(long)> t4; 714 sa<sizeof(sink_5_14568(source())) == 5* sizeof(long)> t5; 715 sa<sizeof(sink_5_14568(c_source())) == 6* sizeof(long)> t6; 716 sa<sizeof(sink_5_14568(v_source())) == 8* sizeof(long)> t7; 717 sa<sizeof(sink_5_14568(cv_source())) == 8* sizeof(long)> t8; 718 return 0; 719 } 720 721 one sink_5_14578( A&); 722 four sink_5_14578(const volatile A&); 723 five sink_5_14578( A&&); 724 seven sink_5_14578(volatile A&&); 725 eight sink_5_14578(const volatile A&&); 726 727 int test5_14578() 728 { 729 A a; 730 const A ca; 731 volatile A va; 732 const volatile A cva; 733 sa<sizeof(sink_5_14578(a)) == 1* sizeof(long)> t1; 734 sa<sizeof(sink_5_14578(ca)) == 4* sizeof(long)> t2; 735 sa<sizeof(sink_5_14578(va)) == 4* sizeof(long)> t3; 736 sa<sizeof(sink_5_14578(cva)) == 4* sizeof(long)> t4; 737 sa<sizeof(sink_5_14578(source())) == 5* sizeof(long)> t5; 738 sa<sizeof(sink_5_14578(c_source())) == 8* sizeof(long)> t6; 739 sa<sizeof(sink_5_14578(v_source())) == 7* sizeof(long)> t7; 740 sa<sizeof(sink_5_14578(cv_source())) == 8* sizeof(long)> t8; 741 return 0; 742 } 743 744 one sink_5_14678( A&); 745 four sink_5_14678(const volatile A&); 746 six sink_5_14678(const A&&); 747 seven sink_5_14678(volatile A&&); 748 eight sink_5_14678(const volatile A&&); 749 750 int test5_14678() 751 { 752 A a; 753 const A ca; 754 volatile A va; 755 const volatile A cva; 756 sa<sizeof(sink_5_14678(a)) == 1* sizeof(long)> t1; 757 sa<sizeof(sink_5_14678(ca)) == 4* sizeof(long)> t2; 758 sa<sizeof(sink_5_14678(va)) == 4* sizeof(long)> t3; 759 sa<sizeof(sink_5_14678(cva)) == 4* sizeof(long)> t4; 760 sa<sizeof(sink_5_14678(c_source())) == 6* sizeof(long)> t6; 761 sa<sizeof(sink_5_14678(v_source())) == 7* sizeof(long)> t7; 762 sa<sizeof(sink_5_14678(cv_source())) == 8* sizeof(long)> t8; 763 return 0; 764 } 765 766 one sink_5_15678( A&); 767 five sink_5_15678( A&&); 768 six sink_5_15678(const A&&); 769 seven sink_5_15678(volatile A&&); 770 eight sink_5_15678(const volatile A&&); 771 772 int test5_15678() 773 { 774 A a; 775 const A ca; 776 volatile A va; 777 const volatile A cva; 778 sa<sizeof(sink_5_15678(a)) == 1* sizeof(long)> t1; 779 sa<sizeof(sink_5_15678(source())) == 5* sizeof(long)> t5; 780 sa<sizeof(sink_5_15678(c_source())) == 6* sizeof(long)> t6; 781 sa<sizeof(sink_5_15678(v_source())) == 7* sizeof(long)> t7; 782 sa<sizeof(sink_5_15678(cv_source())) == 8* sizeof(long)> t8; 783 return 0; 784 } 785 786 two sink_5_23456(const A&); 787 three sink_5_23456(volatile A&); 788 four sink_5_23456(const volatile A&); 789 five sink_5_23456( A&&); 790 six sink_5_23456(const A&&); 791 792 int test5_23456() 793 { 794 A a; 795 const A ca; 796 volatile A va; 797 const volatile A cva; 798 sa<sizeof(sink_5_23456(ca)) == 2* sizeof(long)> t2; 799 sa<sizeof(sink_5_23456(va)) == 3* sizeof(long)> t3; 800 sa<sizeof(sink_5_23456(cva)) == 4* sizeof(long)> t4; 801 sa<sizeof(sink_5_23456(source())) == 5* sizeof(long)> t5; 802 sa<sizeof(sink_5_23456(c_source())) == 6* sizeof(long)> t6; 803 return 0; 804 } 805 806 two sink_5_23457(const A&); 807 three sink_5_23457(volatile A&); 808 four sink_5_23457(const volatile A&); 809 five sink_5_23457( A&&); 810 seven sink_5_23457(volatile A&&); 811 812 int test5_23457() 813 { 814 A a; 815 const A ca; 816 volatile A va; 817 const volatile A cva; 818 sa<sizeof(sink_5_23457(ca)) == 2* sizeof(long)> t2; 819 sa<sizeof(sink_5_23457(va)) == 3* sizeof(long)> t3; 820 sa<sizeof(sink_5_23457(cva)) == 4* sizeof(long)> t4; 821 sa<sizeof(sink_5_23457(source())) == 5* sizeof(long)> t5; 822 sa<sizeof(sink_5_23457(c_source())) == 2* sizeof(long)> t6; 823 sa<sizeof(sink_5_23457(v_source())) == 7* sizeof(long)> t7; 824 return 0; 825 } 826 827 two sink_5_23458(const A&); 828 three sink_5_23458(volatile A&); 829 four sink_5_23458(const volatile A&); 830 five sink_5_23458( A&&); 831 eight sink_5_23458(const volatile A&&); 832 833 int test5_23458() 834 { 835 A a; 836 const A ca; 837 volatile A va; 838 const volatile A cva; 839 sa<sizeof(sink_5_23458(ca)) == 2* sizeof(long)> t2; 840 sa<sizeof(sink_5_23458(va)) == 3* sizeof(long)> t3; 841 sa<sizeof(sink_5_23458(cva)) == 4* sizeof(long)> t4; 842 sa<sizeof(sink_5_23458(source())) == 5* sizeof(long)> t5; 843 sa<sizeof(sink_5_23458(c_source())) == 8* sizeof(long)> t6; 844 sa<sizeof(sink_5_23458(v_source())) == 8* sizeof(long)> t7; 845 sa<sizeof(sink_5_23458(cv_source())) == 8* sizeof(long)> t8; 846 return 0; 847 } 848 849 two sink_5_23467(const A&); 850 three sink_5_23467(volatile A&); 851 four sink_5_23467(const volatile A&); 852 six sink_5_23467(const A&&); 853 seven sink_5_23467(volatile A&&); 854 855 int test5_23467() 856 { 857 A a; 858 const A ca; 859 volatile A va; 860 const volatile A cva; 861 sa<sizeof(sink_5_23467(ca)) == 2* sizeof(long)> t2; 862 sa<sizeof(sink_5_23467(va)) == 3* sizeof(long)> t3; 863 sa<sizeof(sink_5_23467(cva)) == 4* sizeof(long)> t4; 864 sa<sizeof(sink_5_23467(c_source())) == 6* sizeof(long)> t6; 865 sa<sizeof(sink_5_23467(v_source())) == 7* sizeof(long)> t7; 866 return 0; 867 } 868 869 two sink_5_23468(const A&); 870 three sink_5_23468(volatile A&); 871 four sink_5_23468(const volatile A&); 872 six sink_5_23468(const A&&); 873 eight sink_5_23468(const volatile A&&); 874 875 int test5_23468() 876 { 877 A a; 878 const A ca; 879 volatile A va; 880 const volatile A cva; 881 sa<sizeof(sink_5_23468(ca)) == 2* sizeof(long)> t2; 882 sa<sizeof(sink_5_23468(va)) == 3* sizeof(long)> t3; 883 sa<sizeof(sink_5_23468(cva)) == 4* sizeof(long)> t4; 884 sa<sizeof(sink_5_23468(source())) == 6* sizeof(long)> t5; 885 sa<sizeof(sink_5_23468(c_source())) == 6* sizeof(long)> t6; 886 sa<sizeof(sink_5_23468(v_source())) == 8* sizeof(long)> t7; 887 sa<sizeof(sink_5_23468(cv_source())) == 8* sizeof(long)> t8; 888 return 0; 889 } 890 891 two sink_5_23478(const A&); 892 three sink_5_23478(volatile A&); 893 four sink_5_23478(const volatile A&); 894 seven sink_5_23478(volatile A&&); 895 eight sink_5_23478(const volatile A&&); 896 897 int test5_23478() 898 { 899 A a; 900 const A ca; 901 volatile A va; 902 const volatile A cva; 903 sa<sizeof(sink_5_23478(ca)) == 2* sizeof(long)> t2; 904 sa<sizeof(sink_5_23478(va)) == 3* sizeof(long)> t3; 905 sa<sizeof(sink_5_23478(cva)) == 4* sizeof(long)> t4; 906 sa<sizeof(sink_5_23478(source())) == 7* sizeof(long)> t5; 907 sa<sizeof(sink_5_23478(c_source())) == 8* sizeof(long)> t6; 908 sa<sizeof(sink_5_23478(v_source())) == 7* sizeof(long)> t7; 909 sa<sizeof(sink_5_23478(cv_source())) == 8* sizeof(long)> t8; 910 return 0; 911 } 912 913 two sink_5_23567(const A&); 914 three sink_5_23567(volatile A&); 915 five sink_5_23567( A&&); 916 six sink_5_23567(const A&&); 917 seven sink_5_23567(volatile A&&); 918 919 int test5_23567() 920 { 921 A a; 922 const A ca; 923 volatile A va; 924 const volatile A cva; 925 sa<sizeof(sink_5_23567(ca)) == 2* sizeof(long)> t2; 926 sa<sizeof(sink_5_23567(va)) == 3* sizeof(long)> t3; 927 sa<sizeof(sink_5_23567(source())) == 5* sizeof(long)> t5; 928 sa<sizeof(sink_5_23567(c_source())) == 6* sizeof(long)> t6; 929 sa<sizeof(sink_5_23567(v_source())) == 7* sizeof(long)> t7; 930 return 0; 931 } 932 933 two sink_5_23568(const A&); 934 three sink_5_23568(volatile A&); 935 five sink_5_23568( A&&); 936 six sink_5_23568(const A&&); 937 eight sink_5_23568(const volatile A&&); 938 939 int test5_23568() 940 { 941 A a; 942 const A ca; 943 volatile A va; 944 const volatile A cva; 945 sa<sizeof(sink_5_23568(ca)) == 2* sizeof(long)> t2; 946 sa<sizeof(sink_5_23568(va)) == 3* sizeof(long)> t3; 947 sa<sizeof(sink_5_23568(source())) == 5* sizeof(long)> t5; 948 sa<sizeof(sink_5_23568(c_source())) == 6* sizeof(long)> t6; 949 sa<sizeof(sink_5_23568(v_source())) == 8* sizeof(long)> t7; 950 sa<sizeof(sink_5_23568(cv_source())) == 8* sizeof(long)> t8; 951 return 0; 952 } 953 954 two sink_5_23578(const A&); 955 three sink_5_23578(volatile A&); 956 five sink_5_23578( A&&); 957 seven sink_5_23578(volatile A&&); 958 eight sink_5_23578(const volatile A&&); 959 960 int test5_23578() 961 { 962 A a; 963 const A ca; 964 volatile A va; 965 const volatile A cva; 966 sa<sizeof(sink_5_23578(ca)) == 2* sizeof(long)> t2; 967 sa<sizeof(sink_5_23578(va)) == 3* sizeof(long)> t3; 968 sa<sizeof(sink_5_23578(source())) == 5* sizeof(long)> t5; 969 sa<sizeof(sink_5_23578(c_source())) == 8* sizeof(long)> t6; 970 sa<sizeof(sink_5_23578(v_source())) == 7* sizeof(long)> t7; 971 sa<sizeof(sink_5_23578(cv_source())) == 8* sizeof(long)> t8; 972 return 0; 973 } 974 975 two sink_5_23678(const A&); 976 three sink_5_23678(volatile A&); 977 six sink_5_23678(const A&&); 978 seven sink_5_23678(volatile A&&); 979 eight sink_5_23678(const volatile A&&); 980 981 int test5_23678() 982 { 983 A a; 984 const A ca; 985 volatile A va; 986 const volatile A cva; 987 sa<sizeof(sink_5_23678(ca)) == 2* sizeof(long)> t2; 988 sa<sizeof(sink_5_23678(va)) == 3* sizeof(long)> t3; 989 sa<sizeof(sink_5_23678(c_source())) == 6* sizeof(long)> t6; 990 sa<sizeof(sink_5_23678(v_source())) == 7* sizeof(long)> t7; 991 sa<sizeof(sink_5_23678(cv_source())) == 8* sizeof(long)> t8; 992 return 0; 993 } 994 995 two sink_5_24567(const A&); 996 four sink_5_24567(const volatile A&); 997 five sink_5_24567( A&&); 998 six sink_5_24567(const A&&); 999 seven sink_5_24567(volatile A&&); 1000 1001 int test5_24567() 1002 { 1003 A a; 1004 const A ca; 1005 volatile A va; 1006 const volatile A cva; 1007 sa<sizeof(sink_5_24567(a)) == 2* sizeof(long)> t1; 1008 sa<sizeof(sink_5_24567(ca)) == 2* sizeof(long)> t2; 1009 sa<sizeof(sink_5_24567(va)) == 4* sizeof(long)> t3; 1010 sa<sizeof(sink_5_24567(cva)) == 4* sizeof(long)> t4; 1011 sa<sizeof(sink_5_24567(source())) == 5* sizeof(long)> t5; 1012 sa<sizeof(sink_5_24567(c_source())) == 6* sizeof(long)> t6; 1013 sa<sizeof(sink_5_24567(v_source())) == 7* sizeof(long)> t7; 1014 return 0; 1015 } 1016 1017 two sink_5_24568(const A&); 1018 four sink_5_24568(const volatile A&); 1019 five sink_5_24568( A&&); 1020 six sink_5_24568(const A&&); 1021 eight sink_5_24568(const volatile A&&); 1022 1023 int test5_24568() 1024 { 1025 A a; 1026 const A ca; 1027 volatile A va; 1028 const volatile A cva; 1029 sa<sizeof(sink_5_24568(a)) == 2* sizeof(long)> t1; 1030 sa<sizeof(sink_5_24568(ca)) == 2* sizeof(long)> t2; 1031 sa<sizeof(sink_5_24568(va)) == 4* sizeof(long)> t3; 1032 sa<sizeof(sink_5_24568(cva)) == 4* sizeof(long)> t4; 1033 sa<sizeof(sink_5_24568(source())) == 5* sizeof(long)> t5; 1034 sa<sizeof(sink_5_24568(c_source())) == 6* sizeof(long)> t6; 1035 sa<sizeof(sink_5_24568(v_source())) == 8* sizeof(long)> t7; 1036 sa<sizeof(sink_5_24568(cv_source())) == 8* sizeof(long)> t8; 1037 return 0; 1038 } 1039 1040 two sink_5_24578(const A&); 1041 four sink_5_24578(const volatile A&); 1042 five sink_5_24578( A&&); 1043 seven sink_5_24578(volatile A&&); 1044 eight sink_5_24578(const volatile A&&); 1045 1046 int test5_24578() 1047 { 1048 A a; 1049 const A ca; 1050 volatile A va; 1051 const volatile A cva; 1052 sa<sizeof(sink_5_24578(a)) == 2* sizeof(long)> t1; 1053 sa<sizeof(sink_5_24578(ca)) == 2* sizeof(long)> t2; 1054 sa<sizeof(sink_5_24578(va)) == 4* sizeof(long)> t3; 1055 sa<sizeof(sink_5_24578(cva)) == 4* sizeof(long)> t4; 1056 sa<sizeof(sink_5_24578(source())) == 5* sizeof(long)> t5; 1057 sa<sizeof(sink_5_24578(c_source())) == 8* sizeof(long)> t6; 1058 sa<sizeof(sink_5_24578(v_source())) == 7* sizeof(long)> t7; 1059 sa<sizeof(sink_5_24578(cv_source())) == 8* sizeof(long)> t8; 1060 return 0; 1061 } 1062 1063 two sink_5_24678(const A&); 1064 four sink_5_24678(const volatile A&); 1065 six sink_5_24678(const A&&); 1066 seven sink_5_24678(volatile A&&); 1067 eight sink_5_24678(const volatile A&&); 1068 1069 int test5_24678() 1070 { 1071 A a; 1072 const A ca; 1073 volatile A va; 1074 const volatile A cva; 1075 sa<sizeof(sink_5_24678(a)) == 2* sizeof(long)> t1; 1076 sa<sizeof(sink_5_24678(ca)) == 2* sizeof(long)> t2; 1077 sa<sizeof(sink_5_24678(va)) == 4* sizeof(long)> t3; 1078 sa<sizeof(sink_5_24678(cva)) == 4* sizeof(long)> t4; 1079 sa<sizeof(sink_5_24678(c_source())) == 6* sizeof(long)> t6; 1080 sa<sizeof(sink_5_24678(v_source())) == 7* sizeof(long)> t7; 1081 sa<sizeof(sink_5_24678(cv_source())) == 8* sizeof(long)> t8; 1082 return 0; 1083 } 1084 1085 two sink_5_25678(const A&); 1086 five sink_5_25678( A&&); 1087 six sink_5_25678(const A&&); 1088 seven sink_5_25678(volatile A&&); 1089 eight sink_5_25678(const volatile A&&); 1090 1091 int test5_25678() 1092 { 1093 A a; 1094 const A ca; 1095 volatile A va; 1096 const volatile A cva; 1097 sa<sizeof(sink_5_25678(a)) == 2* sizeof(long)> t1; 1098 sa<sizeof(sink_5_25678(ca)) == 2* sizeof(long)> t2; 1099 sa<sizeof(sink_5_25678(source())) == 5* sizeof(long)> t5; 1100 sa<sizeof(sink_5_25678(c_source())) == 6* sizeof(long)> t6; 1101 sa<sizeof(sink_5_25678(v_source())) == 7* sizeof(long)> t7; 1102 sa<sizeof(sink_5_25678(cv_source())) == 8* sizeof(long)> t8; 1103 return 0; 1104 } 1105 1106 three sink_5_34567(volatile A&); 1107 four sink_5_34567(const volatile A&); 1108 five sink_5_34567( A&&); 1109 six sink_5_34567(const A&&); 1110 seven sink_5_34567(volatile A&&); 1111 1112 int test5_34567() 1113 { 1114 A a; 1115 const A ca; 1116 volatile A va; 1117 const volatile A cva; 1118 sa<sizeof(sink_5_34567(a)) == 3* sizeof(long)> t1; 1119 sa<sizeof(sink_5_34567(ca)) == 4* sizeof(long)> t2; 1120 sa<sizeof(sink_5_34567(va)) == 3* sizeof(long)> t3; 1121 sa<sizeof(sink_5_34567(cva)) == 4* sizeof(long)> t4; 1122 sa<sizeof(sink_5_34567(source())) == 5* sizeof(long)> t5; 1123 sa<sizeof(sink_5_34567(c_source())) == 6* sizeof(long)> t6; 1124 sa<sizeof(sink_5_34567(v_source())) == 7* sizeof(long)> t7; 1125 return 0; 1126 } 1127 1128 three sink_5_34568(volatile A&); 1129 four sink_5_34568(const volatile A&); 1130 five sink_5_34568( A&&); 1131 six sink_5_34568(const A&&); 1132 eight sink_5_34568(const volatile A&&); 1133 1134 int test5_34568() 1135 { 1136 A a; 1137 const A ca; 1138 volatile A va; 1139 const volatile A cva; 1140 sa<sizeof(sink_5_34568(a)) == 3* sizeof(long)> t1; 1141 sa<sizeof(sink_5_34568(ca)) == 4* sizeof(long)> t2; 1142 sa<sizeof(sink_5_34568(va)) == 3* sizeof(long)> t3; 1143 sa<sizeof(sink_5_34568(cva)) == 4* sizeof(long)> t4; 1144 sa<sizeof(sink_5_34568(source())) == 5* sizeof(long)> t5; 1145 sa<sizeof(sink_5_34568(c_source())) == 6* sizeof(long)> t6; 1146 sa<sizeof(sink_5_34568(v_source())) == 8* sizeof(long)> t7; 1147 sa<sizeof(sink_5_34568(cv_source())) == 8* sizeof(long)> t8; 1148 return 0; 1149 } 1150 1151 three sink_5_34578(volatile A&); 1152 four sink_5_34578(const volatile A&); 1153 five sink_5_34578( A&&); 1154 seven sink_5_34578(volatile A&&); 1155 eight sink_5_34578(const volatile A&&); 1156 1157 int test5_34578() 1158 { 1159 A a; 1160 const A ca; 1161 volatile A va; 1162 const volatile A cva; 1163 sa<sizeof(sink_5_34578(a)) == 3* sizeof(long)> t1; 1164 sa<sizeof(sink_5_34578(ca)) == 4* sizeof(long)> t2; 1165 sa<sizeof(sink_5_34578(va)) == 3* sizeof(long)> t3; 1166 sa<sizeof(sink_5_34578(cva)) == 4* sizeof(long)> t4; 1167 sa<sizeof(sink_5_34578(source())) == 5* sizeof(long)> t5; 1168 sa<sizeof(sink_5_34578(c_source())) == 8* sizeof(long)> t6; 1169 sa<sizeof(sink_5_34578(v_source())) == 7* sizeof(long)> t7; 1170 sa<sizeof(sink_5_34578(cv_source())) == 8* sizeof(long)> t8; 1171 return 0; 1172 } 1173 1174 three sink_5_34678(volatile A&); 1175 four sink_5_34678(const volatile A&); 1176 six sink_5_34678(const A&&); 1177 seven sink_5_34678(volatile A&&); 1178 eight sink_5_34678(const volatile A&&); 1179 1180 int test5_34678() 1181 { 1182 A a; 1183 const A ca; 1184 volatile A va; 1185 const volatile A cva; 1186 sa<sizeof(sink_5_34678(a)) == 3 * sizeof(long)> t1; 1187 sa<sizeof(sink_5_34678(ca)) == 4 * sizeof(long)> t2; 1188 sa<sizeof(sink_5_34678(va)) == 3 * sizeof(long)> t3; 1189 sa<sizeof(sink_5_34678(cva)) == 4 * sizeof(long)> t4; 1190 sa<sizeof(sink_5_34678(c_source())) == 6 * sizeof(long)> t6; 1191 sa<sizeof(sink_5_34678(v_source())) == 7 * sizeof(long)> t7; 1192 sa<sizeof(sink_5_34678(cv_source())) == 8 * sizeof(long)> t8; 1193 return 0; 1194 } 1195 1196 three sink_5_35678(volatile A&); 1197 five sink_5_35678( A&&); 1198 six sink_5_35678(const A&&); 1199 seven sink_5_35678(volatile A&&); 1200 eight sink_5_35678(const volatile A&&); 1201 1202 int test5_35678() 1203 { 1204 A a; 1205 const A ca; 1206 volatile A va; 1207 const volatile A cva; 1208 sa<sizeof(sink_5_35678(a)) == 3 * sizeof(long)> t1; 1209 sa<sizeof(sink_5_35678(va)) == 3 * sizeof(long)> t3; 1210 sa<sizeof(sink_5_35678(source())) == 5 * sizeof(long)> t5; 1211 sa<sizeof(sink_5_35678(c_source())) == 6 * sizeof(long)> t6; 1212 sa<sizeof(sink_5_35678(v_source())) == 7 * sizeof(long)> t7; 1213 sa<sizeof(sink_5_35678(cv_source())) == 8 * sizeof(long)> t8; 1214 return 0; 1215 } 1216 1217 four sink_5_45678(const volatile A&); 1218 five sink_5_45678( A&&); 1219 six sink_5_45678(const A&&); 1220 seven sink_5_45678(volatile A&&); 1221 eight sink_5_45678(const volatile A&&); 1222 1223 int test5_45678() 1224 { 1225 A a; 1226 const A ca; 1227 volatile A va; 1228 const volatile A cva; 1229 sa<sizeof(sink_5_45678(a)) == 4 * sizeof(long)> t1; 1230 sa<sizeof(sink_5_45678(ca)) == 4 * sizeof(long)> t2; 1231 sa<sizeof(sink_5_45678(va)) == 4 * sizeof(long)> t3; 1232 sa<sizeof(sink_5_45678(cva)) == 4 * sizeof(long)> t4; 1233 sa<sizeof(sink_5_45678(source())) == 5 * sizeof(long)> t5; 1234 sa<sizeof(sink_5_45678(c_source())) == 6 * sizeof(long)> t6; 1235 sa<sizeof(sink_5_45678(v_source())) == 7 * sizeof(long)> t7; 1236 sa<sizeof(sink_5_45678(cv_source())) == 8 * sizeof(long)> t8; 1237 return 0; 1238 } 1239 1240 int main() 1241 { 1242 return test5_12345() + test5_12346() + test5_12347() + test5_12348() + 1243 test5_12356() + test5_12357() + test5_12358() + test5_12367() + 1244 test5_12368() + test5_12378() + test5_12456() + test5_12457() + 1245 test5_12458() + test5_12467() + test5_12468() + test5_12478() + 1246 test5_12567() + test5_12568() + test5_12578() + test5_12678() + 1247 test5_13456() + test5_13457() + test5_13458() + test5_13467() + 1248 test5_13468() + test5_13478() + test5_13567() + test5_13568() + 1249 test5_13578() + test5_13678() + test5_14567() + test5_14568() + 1250 test5_14578() + test5_14678() + test5_15678() + test5_23456() + 1251 test5_23457() + test5_23458() + test5_23467() + test5_23468() + 1252 test5_23478() + test5_23567() + test5_23568() + test5_23578() + 1253 test5_23678() + test5_24567() + test5_24568() + test5_24578() + 1254 test5_24678() + test5_25678() + test5_34567() + test5_34568() + 1255 test5_34578() + test5_34678() + test5_35678() + test5_45678(); 1256 } 1257