gcc/testsuite/g++.dg/cpp0x/rv4p.C

   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 }
   6 // { dg-options "-std=c++0x" }
   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();
  29 const volatile A cv_source();
  30
  31 // 4 at a time
  32
  33 one   sink_4_1234(               A&);
  34 two   sink_4_1234(const          A&);
  35 three sink_4_1234(volatile       A&);
  36 four  sink_4_1234(const volatile A&);
  37
  38 int test4_1234()
  39 {
  40                    A a;
  41     const          A ca;
  42           volatile A va;
  43     const volatile A cva;
  44     sa<sizeof(sink_4_1234(a))           == 1 * sizeof(long)> t1;
  45     sa<sizeof(sink_4_1234(ca))          == 2 * sizeof(long)> t2;
  46     sa<sizeof(sink_4_1234(va))          == 3 * sizeof(long)> t3;
  47     sa<sizeof(sink_4_1234(cva))         == 4 * sizeof(long)> t4;
  48     sa<sizeof(sink_4_1234(source()))    == 2 * sizeof(long)> t5;
  49     sa<sizeof(sink_4_1234(c_source()))  == 2 * sizeof(long)> t6;
  50     return 0;
  51 }
  52
  53 one   sink_4_1235(               A&);
  54 two   sink_4_1235(const          A&);
  55 three sink_4_1235(volatile       A&);
  56 five  sink_4_1235(               A&&);
  57
  58 int test4_1235()
  59 {
  60                    A a;
  61     const          A ca;
  62           volatile A va;
  63     const volatile A cva;
  64     sa<sizeof(sink_4_1235(a))           == 1 * sizeof(long)> t1;
  65     sa<sizeof(sink_4_1235(ca))          == 2 * sizeof(long)> t2;
  66     sa<sizeof(sink_4_1235(va))          == 3 * sizeof(long)> t3;
  67     sa<sizeof(sink_4_1235(source()))    == 5 * sizeof(long)> t5;
  68     sa<sizeof(sink_4_1235(c_source()))  == 2 * sizeof(long)> t6;
  69     return 0;
  70 }
  71
  72 one   sink_4_1236(               A&);
  73 two   sink_4_1236(const          A&);
  74 three sink_4_1236(volatile       A&);
  75 six   sink_4_1236(const          A&&);
  76
  77 int test4_1236()
  78 {
  79                    A a;
  80     const          A ca;
  81           volatile A va;
  82     const volatile A cva;
  83     sa<sizeof(sink_4_1236(a))           == 1 * sizeof(long)> t1;
  84     sa<sizeof(sink_4_1236(ca))          == 2 * sizeof(long)> t2;
  85     sa<sizeof(sink_4_1236(va))          == 3 * sizeof(long)> t3;
  86     sa<sizeof(sink_4_1236(source()))    == 6 * sizeof(long)> t5;
  87     sa<sizeof(sink_4_1236(c_source()))  == 6 * sizeof(long)> t6;
  88     return 0;
  89 }
  90
  91 one   sink_4_1237(               A&);
  92 two   sink_4_1237(const          A&);
  93 three sink_4_1237(volatile       A&);
  94 seven sink_4_1237(volatile       A&&);
  95
  96 int test4_1237()
  97 {
  98                    A a;
  99     const          A ca;
 100           volatile A va;
 101     const volatile A cva;
 102     sa<sizeof(sink_4_1237(a))           == 1 * sizeof(long)> t1;
 103     sa<sizeof(sink_4_1237(ca))          == 2 * sizeof(long)> t2;
 104     sa<sizeof(sink_4_1237(va))          == 3 * sizeof(long)> t3;
 105     sa<sizeof(sink_4_1237(source()))    == 7 * sizeof(long)> t5;
 106     sa<sizeof(sink_4_1237(c_source()))  == 2 * sizeof(long)> t6;
 107     sa<sizeof(sink_4_1237(v_source()))  == 7 * sizeof(long)> t7;
 108     return 0;
 109 }
 110
 111 one   sink_4_1238(               A&);
 112 two   sink_4_1238(const          A&);
 113 three sink_4_1238(volatile       A&);
 114 eight sink_4_1238(const volatile A&&);
 115
 116 int test4_1238()
 117 {
 118                    A a;
 119     const          A ca;
 120           volatile A va;
 121     const volatile A cva;
 122     sa<sizeof(sink_4_1238(a))           == 1 * sizeof(long)> t1;
 123     sa<sizeof(sink_4_1238(ca))          == 2 * sizeof(long)> t2;
 124     sa<sizeof(sink_4_1238(va))          == 3 * sizeof(long)> t3;
 125     sa<sizeof(sink_4_1238(source()))    == 8 * sizeof(long)> t5;
 126     sa<sizeof(sink_4_1238(c_source()))  == 8 * sizeof(long)> t6;
 127     sa<sizeof(sink_4_1238(v_source()))  == 8 * sizeof(long)> t7;
 128     sa<sizeof(sink_4_1238(cv_source())) == 8 * sizeof(long)> t8;
 129     return 0;
 130 }
 131
 132 one   sink_4_1245(               A&);
 133 two   sink_4_1245(const          A&);
 134 four  sink_4_1245(const volatile A&);
 135 five  sink_4_1245(               A&&);
 136
 137 int test4_1245()
 138 {
 139                    A a;
 140     const          A ca;
 141           volatile A va;
 142     const volatile A cva;
 143     sa<sizeof(sink_4_1245(a))           == 1 * sizeof(long)> t1;
 144     sa<sizeof(sink_4_1245(ca))          == 2 * sizeof(long)> t2;
 145     sa<sizeof(sink_4_1245(va))          == 4 * sizeof(long)> t3;
 146     sa<sizeof(sink_4_1245(cva))         == 4 * sizeof(long)> t4;
 147     sa<sizeof(sink_4_1245(source()))    == 5 * sizeof(long)> t5;
 148     sa<sizeof(sink_4_1245(c_source()))  == 2 * sizeof(long)> t6;
 149     return 0;
 150 }
 151
 152 one   sink_4_1246(               A&);
 153 two   sink_4_1246(const          A&);
 154 four  sink_4_1246(const volatile A&);
 155 six   sink_4_1246(const          A&&);
 156
 157 int test4_1246()
 158 {
 159                    A a;
 160     const          A ca;
 161           volatile A va;
 162     const volatile A cva;
 163     sa<sizeof(sink_4_1246(a))           == 1 * sizeof(long)> t1;
 164     sa<sizeof(sink_4_1246(ca))          == 2 * sizeof(long)> t2;
 165     sa<sizeof(sink_4_1246(va))          == 4 * sizeof(long)> t3;
 166     sa<sizeof(sink_4_1246(cva))         == 4 * sizeof(long)> t4;
 167     sa<sizeof(sink_4_1246(source()))    == 6 * sizeof(long)> t5;
 168     sa<sizeof(sink_4_1246(c_source()))  == 6 * sizeof(long)> t6;
 169     return 0;
 170 }
 171
 172 one   sink_4_1247(               A&);
 173 two   sink_4_1247(const          A&);
 174 four  sink_4_1247(const volatile A&);
 175 seven sink_4_1247(volatile       A&&);
 176
 177 int test4_1247()
 178 {
 179                    A a;
 180     const          A ca;
 181           volatile A va;
 182     const volatile A cva;
 183     sa<sizeof(sink_4_1247(a))           == 1 * sizeof(long)> t1;
 184     sa<sizeof(sink_4_1247(ca))          == 2 * sizeof(long)> t2;
 185     sa<sizeof(sink_4_1247(va))          == 4 * sizeof(long)> t3;
 186     sa<sizeof(sink_4_1247(cva))         == 4 * sizeof(long)> t4;
 187     sa<sizeof(sink_4_1247(source()))    == 7 * sizeof(long)> t5;
 188     sa<sizeof(sink_4_1247(c_source()))  == 2 * sizeof(long)> t6;
 189     sa<sizeof(sink_4_1247(v_source()))  == 7 * sizeof(long)> t7;
 190     return 0;
 191 }
 192
 193 one   sink_4_1248(               A&);
 194 two   sink_4_1248(const          A&);
 195 four  sink_4_1248(const volatile A&);
 196 eight sink_4_1248(const volatile A&&);
 197
 198 int test4_1248()
 199 {
 200                    A a;
 201     const          A ca;
 202           volatile A va;
 203     const volatile A cva;
 204     sa<sizeof(sink_4_1248(a))           == 1 * sizeof(long)> t1;
 205     sa<sizeof(sink_4_1248(ca))          == 2 * sizeof(long)> t2;
 206     sa<sizeof(sink_4_1248(va))          == 4 * sizeof(long)> t3;
 207     sa<sizeof(sink_4_1248(cva))         == 4 * sizeof(long)> t4;
 208     sa<sizeof(sink_4_1248(source()))    == 8 * sizeof(long)> t5;
 209     sa<sizeof(sink_4_1248(c_source()))  == 8 * sizeof(long)> t6;
 210     sa<sizeof(sink_4_1248(v_source()))  == 8 * sizeof(long)> t7;
 211     sa<sizeof(sink_4_1248(cv_source())) == 8 * sizeof(long)> t8;
 212     return 0;
 213 }
 214
 215 one   sink_4_1256(               A&);
 216 two   sink_4_1256(const          A&);
 217 five  sink_4_1256(               A&&);
 218 six   sink_4_1256(const          A&&);
 219
 220 int test4_1256()
 221 {
 222                    A a;
 223     const          A ca;
 224           volatile A va;
 225     const volatile A cva;
 226     sa<sizeof(sink_4_1256(a))           == 1 * sizeof(long)> t1;
 227     sa<sizeof(sink_4_1256(ca))          == 2 * sizeof(long)> t2;
 228     sa<sizeof(sink_4_1256(source()))    == 5 * sizeof(long)> t5;
 229     sa<sizeof(sink_4_1256(c_source()))  == 6 * sizeof(long)> t6;
 230     return 0;
 231 }
 232
 233 one   sink_4_1257(               A&);
 234 two   sink_4_1257(const          A&);
 235 five  sink_4_1257(               A&&);
 236 seven sink_4_1257(volatile       A&&);
 237
 238 int test4_1257()
 239 {
 240                    A a;
 241     const          A ca;
 242           volatile A va;
 243     const volatile A cva;
 244     sa<sizeof(sink_4_1257(a))           == 1 * sizeof(long)> t1;
 245     sa<sizeof(sink_4_1257(ca))          == 2 * sizeof(long)> t2;
 246     sa<sizeof(sink_4_1257(source()))    == 5 * sizeof(long)> t5;
 247     sa<sizeof(sink_4_1257(c_source()))  == 2 * sizeof(long)> t6;
 248     sa<sizeof(sink_4_1257(v_source()))  == 7 * sizeof(long)> t7;
 249     return 0;
 250 }
 251
 252 one   sink_4_1258(               A&);
 253 two   sink_4_1258(const          A&);
 254 five  sink_4_1258(               A&&);
 255 eight sink_4_1258(const volatile A&&);
 256
 257 int test4_1258()
 258 {
 259                    A a;
 260     const          A ca;
 261           volatile A va;
 262     const volatile A cva;
 263     sa<sizeof(sink_4_1258(a))           == 1 * sizeof(long)> t1;
 264     sa<sizeof(sink_4_1258(ca))          == 2 * sizeof(long)> t2;
 265     sa<sizeof(sink_4_1258(source()))    == 5 * sizeof(long)> t5;
 266     sa<sizeof(sink_4_1258(c_source()))  == 8 * sizeof(long)> t6;
 267     sa<sizeof(sink_4_1258(v_source()))  == 8 * sizeof(long)> t7;
 268     sa<sizeof(sink_4_1258(cv_source())) == 8 * sizeof(long)> t8;
 269     return 0;
 270 }
 271
 272 one   sink_4_1267(               A&);
 273 two   sink_4_1267(const          A&);
 274 six   sink_4_1267(const          A&&);
 275 seven sink_4_1267(volatile       A&&);
 276
 277 int test4_1267()
 278 {
 279                    A a;
 280     const          A ca;
 281           volatile A va;
 282     const volatile A cva;
 283     sa<sizeof(sink_4_1267(a))           == 1 * sizeof(long)> t1;
 284     sa<sizeof(sink_4_1267(ca))          == 2 * sizeof(long)> t2;
 285     sa<sizeof(sink_4_1267(c_source()))  == 6 * sizeof(long)> t6;
 286     sa<sizeof(sink_4_1267(v_source()))  == 7 * sizeof(long)> t7;
 287     return 0;
 288 }
 289
 290 one   sink_4_1268(               A&);
 291 two   sink_4_1268(const          A&);
 292 six   sink_4_1268(const          A&&);
 293 eight sink_4_1268(const volatile A&&);
 294
 295 int test4_1268()
 296 {
 297                    A a;
 298     const          A ca;
 299           volatile A va;
 300     const volatile A cva;
 301     sa<sizeof(sink_4_1268(a))           == 1 * sizeof(long)> t1;
 302     sa<sizeof(sink_4_1268(ca))          == 2 * sizeof(long)> t2;
 303     sa<sizeof(sink_4_1268(source()))    == 6 * sizeof(long)> t5;
 304     sa<sizeof(sink_4_1268(c_source()))  == 6 * sizeof(long)> t6;
 305     sa<sizeof(sink_4_1268(v_source()))  == 8 * sizeof(long)> t7;
 306     sa<sizeof(sink_4_1268(cv_source())) == 8 * sizeof(long)> t8;
 307     return 0;
 308 }
 309
 310 one   sink_4_1278(               A&);
 311 two   sink_4_1278(const          A&);
 312 seven sink_4_1278(volatile       A&&);
 313 eight sink_4_1278(const volatile A&&);
 314
 315 int test4_1278()
 316 {
 317                    A a;
 318     const          A ca;
 319           volatile A va;
 320     const volatile A cva;
 321     sa<sizeof(sink_4_1278(a))           == 1 * sizeof(long)> t1;
 322     sa<sizeof(sink_4_1278(ca))          == 2 * sizeof(long)> t2;
 323     sa<sizeof(sink_4_1278(source()))    == 7 * sizeof(long)> t5;
 324     sa<sizeof(sink_4_1278(c_source()))  == 8 * sizeof(long)> t6;
 325     sa<sizeof(sink_4_1278(v_source()))  == 7 * sizeof(long)> t7;
 326     sa<sizeof(sink_4_1278(cv_source())) == 8 * sizeof(long)> t8;
 327     return 0;
 328 }
 329
 330 one   sink_4_1345(               A&);
 331 three sink_4_1345(volatile       A&);
 332 four  sink_4_1345(const volatile A&);
 333 five  sink_4_1345(               A&&);
 334
 335 int test4_1345()
 336 {
 337                    A a;
 338     const          A ca;
 339           volatile A va;
 340     const volatile A cva;
 341     sa<sizeof(sink_4_1345(a))           == 1 * sizeof(long)> t1;
 342     sa<sizeof(sink_4_1345(ca))          == 4 * sizeof(long)> t2;
 343     sa<sizeof(sink_4_1345(va))          == 3 * sizeof(long)> t3;
 344     sa<sizeof(sink_4_1345(cva))         == 4 * sizeof(long)> t4;
 345     sa<sizeof(sink_4_1345(source()))    == 5 * sizeof(long)> t5;
 346     return 0;
 347 }
 348
 349 one   sink_4_1346(               A&);
 350 three sink_4_1346(volatile       A&);
 351 four  sink_4_1346(const volatile A&);
 352 six   sink_4_1346(const          A&&);
 353
 354 int test4_1346()
 355 {
 356                    A a;
 357     const          A ca;
 358           volatile A va;
 359     const volatile A cva;
 360     sa<sizeof(sink_4_1346(a))           == 1 * sizeof(long)> t1;
 361     sa<sizeof(sink_4_1346(ca))          == 4 * sizeof(long)> t2;
 362     sa<sizeof(sink_4_1346(va))          == 3 * sizeof(long)> t3;
 363     sa<sizeof(sink_4_1346(cva))         == 4 * sizeof(long)> t4;
 364     sa<sizeof(sink_4_1346(source()))    == 6 * sizeof(long)> t5;
 365     sa<sizeof(sink_4_1346(c_source()))  == 6 * sizeof(long)> t6;
 366     return 0;
 367 }
 368
 369 one   sink_4_1347(               A&);
 370 three sink_4_1347(volatile       A&);
 371 four  sink_4_1347(const volatile A&);
 372 seven sink_4_1347(volatile       A&&);
 373
 374 int test4_1347()
 375 {
 376                    A a;
 377     const          A ca;
 378           volatile A va;
 379     const volatile A cva;
 380     sa<sizeof(sink_4_1347(a))           == 1 * sizeof(long)> t1;
 381     sa<sizeof(sink_4_1347(ca))          == 4 * sizeof(long)> t2;
 382     sa<sizeof(sink_4_1347(va))          == 3 * sizeof(long)> t3;
 383     sa<sizeof(sink_4_1347(cva))         == 4 * sizeof(long)> t4;
 384     sa<sizeof(sink_4_1347(source()))    == 7 * sizeof(long)> t5;
 385     sa<sizeof(sink_4_1347(v_source()))  == 7 * sizeof(long)> t7;
 386     return 0;
 387 }
 388
 389 one   sink_4_1348(               A&);
 390 three sink_4_1348(volatile       A&);
 391 four  sink_4_1348(const volatile A&);
 392 eight sink_4_1348(const volatile A&&);
 393
 394 int test4_1348()
 395 {
 396                    A a;
 397     const          A ca;
 398           volatile A va;
 399     const volatile A cva;
 400     sa<sizeof(sink_4_1348(a))           == 1 * sizeof(long)> t1;
 401     sa<sizeof(sink_4_1348(ca))          == 4 * sizeof(long)> t2;
 402     sa<sizeof(sink_4_1348(va))          == 3 * sizeof(long)> t3;
 403     sa<sizeof(sink_4_1348(cva))         == 4 * sizeof(long)> t4;
 404     sa<sizeof(sink_4_1348(source()))    == 8 * sizeof(long)> t5;
 405     sa<sizeof(sink_4_1348(c_source()))  == 8 * sizeof(long)> t6;
 406     sa<sizeof(sink_4_1348(v_source()))  == 8 * sizeof(long)> t7;
 407     sa<sizeof(sink_4_1348(cv_source())) == 8 * sizeof(long)> t8;
 408     return 0;
 409 }
 410
 411 one   sink_4_1356(               A&);
 412 three sink_4_1356(volatile       A&);
 413 five  sink_4_1356(               A&&);
 414 six   sink_4_1356(const          A&&);
 415
 416 int test4_1356()
 417 {
 418                    A a;
 419     const          A ca;
 420           volatile A va;
 421     const volatile A cva;
 422     sa<sizeof(sink_4_1356(a))           == 1 * sizeof(long)> t1;
 423     sa<sizeof(sink_4_1356(va))          == 3 * sizeof(long)> t3;
 424     sa<sizeof(sink_4_1356(source()))    == 5 * sizeof(long)> t5;
 425     sa<sizeof(sink_4_1356(c_source()))  == 6 * sizeof(long)> t6;
 426     return 0;
 427 }
 428
 429 one   sink_4_1357(               A&);
 430 three sink_4_1357(volatile       A&);
 431 five  sink_4_1357(               A&&);
 432 seven sink_4_1357(volatile       A&&);
 433
 434 int test4_1357()
 435 {
 436                    A a;
 437     const          A ca;
 438           volatile A va;
 439     const volatile A cva;
 440     sa<sizeof(sink_4_1357(a))           == 1 * sizeof(long)> t1;
 441     sa<sizeof(sink_4_1357(va))          == 3 * sizeof(long)> t3;
 442     sa<sizeof(sink_4_1357(source()))    == 5 * sizeof(long)> t5;
 443     sa<sizeof(sink_4_1357(v_source()))  == 7 * sizeof(long)> t7;
 444     return 0;
 445 }
 446
 447 one   sink_4_1358(               A&);
 448 three sink_4_1358(volatile       A&);
 449 five  sink_4_1358(               A&&);
 450 eight sink_4_1358(const volatile A&&);
 451
 452 int test4_1358()
 453 {
 454                    A a;
 455     const          A ca;
 456           volatile A va;
 457     const volatile A cva;
 458     sa<sizeof(sink_4_1358(a))           == 1 * sizeof(long)> t1;
 459     sa<sizeof(sink_4_1358(va))          == 3 * sizeof(long)> t3;
 460     sa<sizeof(sink_4_1358(source()))    == 5 * sizeof(long)> t5;
 461     sa<sizeof(sink_4_1358(c_source()))  == 8 * sizeof(long)> t6;
 462     sa<sizeof(sink_4_1358(v_source()))  == 8 * sizeof(long)> t7;
 463     sa<sizeof(sink_4_1358(cv_source())) == 8 * sizeof(long)> t8;
 464     return 0;
 465 }
 466
 467 one   sink_4_1367(               A&);
 468 three sink_4_1367(volatile       A&);
 469 six   sink_4_1367(const          A&&);
 470 seven sink_4_1367(volatile       A&&);
 471
 472 int test4_1367()
 473 {
 474                    A a;
 475     const          A ca;
 476           volatile A va;
 477     const volatile A cva;
 478     sa<sizeof(sink_4_1367(a))           == 1 * sizeof(long)> t1;
 479     sa<sizeof(sink_4_1367(va))          == 3 * sizeof(long)> t3;
 480     sa<sizeof(sink_4_1367(c_source()))  == 6 * sizeof(long)> t6;
 481     sa<sizeof(sink_4_1367(v_source()))  == 7 * sizeof(long)> t7;
 482     return 0;
 483 }
 484
 485 one   sink_4_1368(               A&);
 486 three sink_4_1368(volatile       A&);
 487 six   sink_4_1368(const          A&&);
 488 eight sink_4_1368(const volatile A&&);
 489
 490 int test4_1368()
 491 {
 492                    A a;
 493     const          A ca;
 494           volatile A va;
 495     const volatile A cva;
 496     sa<sizeof(sink_4_1368(a))           == 1 * sizeof(long)> t1;
 497     sa<sizeof(sink_4_1368(va))          == 3 * sizeof(long)> t3;
 498     sa<sizeof(sink_4_1368(source()))    == 6 * sizeof(long)> t5;
 499     sa<sizeof(sink_4_1368(c_source()))  == 6 * sizeof(long)> t6;
 500     sa<sizeof(sink_4_1368(v_source()))  == 8 * sizeof(long)> t7;
 501     sa<sizeof(sink_4_1368(cv_source())) == 8 * sizeof(long)> t8;
 502     return 0;
 503 }
 504
 505 one   sink_4_1378(               A&);
 506 three sink_4_1378(volatile       A&);
 507 seven sink_4_1378(volatile       A&&);
 508 eight sink_4_1378(const volatile A&&);
 509
 510 int test4_1378()
 511 {
 512                    A a;
 513     const          A ca;
 514           volatile A va;
 515     const volatile A cva;
 516     sa<sizeof(sink_4_1378(a))           == 1 * sizeof(long)> t1;
 517     sa<sizeof(sink_4_1378(va))          == 3 * sizeof(long)> t3;
 518     sa<sizeof(sink_4_1378(source()))    == 7 * sizeof(long)> t5;
 519     sa<sizeof(sink_4_1378(c_source()))  == 8 * sizeof(long)> t6;
 520     sa<sizeof(sink_4_1378(v_source()))  == 7 * sizeof(long)> t7;
 521     sa<sizeof(sink_4_1378(cv_source())) == 8 * sizeof(long)> t8;
 522     return 0;
 523 }
 524
 525 one   sink_4_1456(               A&);
 526 four  sink_4_1456(const volatile A&);
 527 five  sink_4_1456(               A&&);
 528 six   sink_4_1456(const          A&&);
 529
 530 int test4_1456()
 531 {
 532                    A a;
 533     const          A ca;
 534           volatile A va;
 535     const volatile A cva;
 536     sa<sizeof(sink_4_1456(a))           == 1 * sizeof(long)> t1;
 537     sa<sizeof(sink_4_1456(ca))          == 4 * sizeof(long)> t2;
 538     sa<sizeof(sink_4_1456(va))          == 4 * sizeof(long)> t3;
 539     sa<sizeof(sink_4_1456(cva))         == 4 * sizeof(long)> t4;
 540     sa<sizeof(sink_4_1456(source()))    == 5 * sizeof(long)> t5;
 541     sa<sizeof(sink_4_1456(c_source()))  == 6 * sizeof(long)> t6;
 542     return 0;
 543 }
 544
 545 one   sink_4_1457(               A&);
 546 four  sink_4_1457(const volatile A&);
 547 five  sink_4_1457(               A&&);
 548 seven sink_4_1457(volatile       A&&);
 549
 550 int test4_1457()
 551 {
 552                    A a;
 553     const          A ca;
 554           volatile A va;
 555     const volatile A cva;
 556     sa<sizeof(sink_4_1457(a))           == 1 * sizeof(long)> t1;
 557     sa<sizeof(sink_4_1457(ca))          == 4 * sizeof(long)> t2;
 558     sa<sizeof(sink_4_1457(va))          == 4 * sizeof(long)> t3;
 559     sa<sizeof(sink_4_1457(cva))         == 4 * sizeof(long)> t4;
 560     sa<sizeof(sink_4_1457(source()))    == 5 * sizeof(long)> t5;
 561     sa<sizeof(sink_4_1457(v_source()))  == 7 * sizeof(long)> t7;
 562     return 0;
 563 }
 564
 565 one   sink_4_1458(               A&);
 566 four  sink_4_1458(const volatile A&);
 567 five  sink_4_1458(               A&&);
 568 eight sink_4_1458(const volatile A&&);
 569
 570 int test4_1458()
 571 {
 572                    A a;
 573     const          A ca;
 574           volatile A va;
 575     const volatile A cva;
 576     sa<sizeof(sink_4_1458(a))           == 1 * sizeof(long)> t1;
 577     sa<sizeof(sink_4_1458(ca))          == 4 * sizeof(long)> t2;
 578     sa<sizeof(sink_4_1458(va))          == 4 * sizeof(long)> t3;
 579     sa<sizeof(sink_4_1458(cva))         == 4 * sizeof(long)> t4;
 580     sa<sizeof(sink_4_1458(source()))    == 5 * sizeof(long)> t5;
 581     sa<sizeof(sink_4_1458(c_source()))  == 8 * sizeof(long)> t6;
 582     sa<sizeof(sink_4_1458(v_source()))  == 8 * sizeof(long)> t7;
 583     sa<sizeof(sink_4_1458(cv_source())) == 8 * sizeof(long)> t8;
 584     return 0;
 585 }
 586
 587 one   sink_4_1467(               A&);
 588 four  sink_4_1467(const volatile A&);
 589 six   sink_4_1467(const          A&&);
 590 seven sink_4_1467(volatile       A&&);
 591
 592 int test4_1467()
 593 {
 594                    A a;
 595     const          A ca;
 596           volatile A va;
 597     const volatile A cva;
 598     sa<sizeof(sink_4_1467(a))           == 1 * sizeof(long)> t1;
 599     sa<sizeof(sink_4_1467(ca))          == 4 * sizeof(long)> t2;
 600     sa<sizeof(sink_4_1467(va))          == 4 * sizeof(long)> t3;
 601     sa<sizeof(sink_4_1467(cva))         == 4 * sizeof(long)> t4;
 602     sa<sizeof(sink_4_1467(c_source()))  == 6 * sizeof(long)> t6;
 603     sa<sizeof(sink_4_1467(v_source()))  == 7 * sizeof(long)> t7;
 604     return 0;
 605 }
 606
 607 one   sink_4_1468(               A&);
 608 four  sink_4_1468(const volatile A&);
 609 six   sink_4_1468(const          A&&);
 610 eight sink_4_1468(const volatile A&&);
 611
 612 int test4_1468()
 613 {
 614                    A a;
 615     const          A ca;
 616           volatile A va;
 617     const volatile A cva;
 618     sa<sizeof(sink_4_1468(a))           == 1 * sizeof(long)> t1;
 619     sa<sizeof(sink_4_1468(ca))          == 4 * sizeof(long)> t2;
 620     sa<sizeof(sink_4_1468(va))          == 4 * sizeof(long)> t3;
 621     sa<sizeof(sink_4_1468(cva))         == 4 * sizeof(long)> t4;
 622     sa<sizeof(sink_4_1468(source()))    == 6 * sizeof(long)> t5;
 623     sa<sizeof(sink_4_1468(c_source()))  == 6 * sizeof(long)> t6;
 624     sa<sizeof(sink_4_1468(v_source()))  == 8 * sizeof(long)> t7;
 625     sa<sizeof(sink_4_1468(cv_source())) == 8 * sizeof(long)> t8;
 626     return 0;
 627 }
 628
 629 one   sink_4_1478(               A&);
 630 four  sink_4_1478(const volatile A&);
 631 seven sink_4_1478(volatile       A&&);
 632 eight sink_4_1478(const volatile A&&);
 633
 634 int test4_1478()
 635 {
 636                    A a;
 637     const          A ca;
 638           volatile A va;
 639     const volatile A cva;
 640     sa<sizeof(sink_4_1478(a))           == 1 * sizeof(long)> t1;
 641     sa<sizeof(sink_4_1478(ca))          == 4 * sizeof(long)> t2;
 642     sa<sizeof(sink_4_1478(va))          == 4 * sizeof(long)> t3;
 643     sa<sizeof(sink_4_1478(cva))         == 4 * sizeof(long)> t4;
 644     sa<sizeof(sink_4_1478(source()))    == 7 * sizeof(long)> t5;
 645     sa<sizeof(sink_4_1478(c_source()))  == 8 * sizeof(long)> t6;
 646     sa<sizeof(sink_4_1478(v_source()))  == 7 * sizeof(long)> t7;
 647     sa<sizeof(sink_4_1478(cv_source())) == 8 * sizeof(long)> t8;
 648     return 0;
 649 }
 650
 651 one   sink_4_1567(               A&);
 652 five  sink_4_1567(               A&&);
 653 six   sink_4_1567(const          A&&);
 654 seven sink_4_1567(volatile       A&&);
 655
 656 int test4_1567()
 657 {
 658                    A a;
 659     const          A ca;
 660           volatile A va;
 661     const volatile A cva;
 662     sa<sizeof(sink_4_1567(a))           == 1 * sizeof(long)> t1;
 663     sa<sizeof(sink_4_1567(source()))    == 5 * sizeof(long)> t5;
 664     sa<sizeof(sink_4_1567(c_source()))  == 6 * sizeof(long)> t6;
 665     sa<sizeof(sink_4_1567(v_source()))  == 7 * sizeof(long)> t7;
 666     return 0;
 667 }
 668
 669 one   sink_4_1568(               A&);
 670 five  sink_4_1568(               A&&);
 671 six   sink_4_1568(const          A&&);
 672 eight sink_4_1568(const volatile A&&);
 673
 674 int test4_1568()
 675 {
 676                    A a;
 677     const          A ca;
 678           volatile A va;
 679     const volatile A cva;
 680     sa<sizeof(sink_4_1568(a))           == 1 * sizeof(long)> t1;
 681     sa<sizeof(sink_4_1568(source()))    == 5 * sizeof(long)> t5;
 682     sa<sizeof(sink_4_1568(c_source()))  == 6 * sizeof(long)> t6;
 683     sa<sizeof(sink_4_1568(v_source()))  == 8 * sizeof(long)> t7;
 684     sa<sizeof(sink_4_1568(cv_source())) == 8 * sizeof(long)> t8;
 685     return 0;
 686 }
 687
 688 one   sink_4_1578(               A&);
 689 five  sink_4_1578(               A&&);
 690 seven sink_4_1578(volatile       A&&);
 691 eight sink_4_1578(const volatile A&&);
 692
 693 int test4_1578()
 694 {
 695                    A a;
 696     const          A ca;
 697           volatile A va;
 698     const volatile A cva;
 699     sa<sizeof(sink_4_1578(a))           == 1 * sizeof(long)> t1;
 700     sa<sizeof(sink_4_1578(source()))    == 5 * sizeof(long)> t5;
 701     sa<sizeof(sink_4_1578(c_source()))  == 8 * sizeof(long)> t6;
 702     sa<sizeof(sink_4_1578(v_source()))  == 7 * sizeof(long)> t7;
 703     sa<sizeof(sink_4_1578(cv_source())) == 8 * sizeof(long)> t8;
 704     return 0;
 705 }
 706
 707 one   sink_4_1678(               A&);
 708 six   sink_4_1678(const          A&&);
 709 seven sink_4_1678(volatile       A&&);
 710 eight sink_4_1678(const volatile A&&);
 711
 712 int test4_1678()
 713 {
 714                    A a;
 715     const          A ca;
 716           volatile A va;
 717     const volatile A cva;
 718     sa<sizeof(sink_4_1678(a))           == 1 * sizeof(long)> t1;
 719     sa<sizeof(sink_4_1678(c_source()))  == 6 * sizeof(long)> t6;
 720     sa<sizeof(sink_4_1678(v_source()))  == 7 * sizeof(long)> t7;
 721     sa<sizeof(sink_4_1678(cv_source())) == 8 * sizeof(long)> t8;
 722     return 0;
 723 }
 724
 725 two   sink_4_2345(const          A&);
 726 three sink_4_2345(volatile       A&);
 727 four  sink_4_2345(const volatile A&);
 728 five  sink_4_2345(               A&&);
 729
 730 int test4_2345()
 731 {
 732                    A a;
 733     const          A ca;
 734           volatile A va;
 735     const volatile A cva;
 736     sa<sizeof(sink_4_2345(ca))          == 2 * sizeof(long)> t2;
 737     sa<sizeof(sink_4_2345(va))          == 3 * sizeof(long)> t3;
 738     sa<sizeof(sink_4_2345(cva))         == 4 * sizeof(long)> t4;
 739     sa<sizeof(sink_4_2345(source()))    == 5 * sizeof(long)> t5;
 740     sa<sizeof(sink_4_2345(c_source()))  == 2 * sizeof(long)> t6;
 741     return 0;
 742 }
 743
 744 two   sink_4_2346(const          A&);
 745 three sink_4_2346(volatile       A&);
 746 four  sink_4_2346(const volatile A&);
 747 six   sink_4_2346(const          A&&);
 748
 749 int test4_2346()
 750 {
 751                    A a;
 752     const          A ca;
 753           volatile A va;
 754     const volatile A cva;
 755     sa<sizeof(sink_4_2346(ca))          == 2 * sizeof(long)> t2;
 756     sa<sizeof(sink_4_2346(va))          == 3 * sizeof(long)> t3;
 757     sa<sizeof(sink_4_2346(cva))         == 4 * sizeof(long)> t4;
 758     sa<sizeof(sink_4_2346(source()))    == 6 * sizeof(long)> t5;
 759     sa<sizeof(sink_4_2346(c_source()))  == 6 * sizeof(long)> t6;
 760     return 0;
 761 }
 762
 763 two   sink_4_2347(const          A&);
 764 three sink_4_2347(volatile       A&);
 765 four  sink_4_2347(const volatile A&);
 766 seven sink_4_2347(volatile       A&&);
 767
 768 int test4_2347()
 769 {
 770                    A a;
 771     const          A ca;
 772           volatile A va;
 773     const volatile A cva;
 774     sa<sizeof(sink_4_2347(ca))          == 2 * sizeof(long)> t2;
 775     sa<sizeof(sink_4_2347(va))          == 3 * sizeof(long)> t3;
 776     sa<sizeof(sink_4_2347(cva))         == 4 * sizeof(long)> t4;
 777     sa<sizeof(sink_4_2347(source()))    == 7 * sizeof(long)> t5;
 778     sa<sizeof(sink_4_2347(c_source()))  == 2 * sizeof(long)> t6;
 779     sa<sizeof(sink_4_2347(v_source()))  == 7 * sizeof(long)> t7;
 780     return 0;
 781 }
 782
 783 two   sink_4_2348(const          A&);
 784 three sink_4_2348(volatile       A&);
 785 four  sink_4_2348(const volatile A&);
 786 eight sink_4_2348(const volatile A&&);
 787
 788 int test4_2348()
 789 {
 790                    A a;
 791     const          A ca;
 792           volatile A va;
 793     const volatile A cva;
 794     sa<sizeof(sink_4_2348(ca))          == 2 * sizeof(long)> t2;
 795     sa<sizeof(sink_4_2348(va))          == 3 * sizeof(long)> t3;
 796     sa<sizeof(sink_4_2348(cva))         == 4 * sizeof(long)> t4;
 797     sa<sizeof(sink_4_2348(source()))    == 8 * sizeof(long)> t5;
 798     sa<sizeof(sink_4_2348(c_source()))  == 8 * sizeof(long)> t6;
 799     sa<sizeof(sink_4_2348(v_source()))  == 8 * sizeof(long)> t7;
 800     sa<sizeof(sink_4_2348(cv_source())) == 8 * sizeof(long)> t8;
 801     return 0;
 802 }
 803
 804 two   sink_4_2356(const          A&);
 805 three sink_4_2356(volatile       A&);
 806 five  sink_4_2356(               A&&);
 807 six   sink_4_2356(const          A&&);
 808
 809 int test4_2356()
 810 {
 811                    A a;
 812     const          A ca;
 813           volatile A va;
 814     const volatile A cva;
 815     sa<sizeof(sink_4_2356(ca))          == 2 * sizeof(long)> t2;
 816     sa<sizeof(sink_4_2356(va))          == 3 * sizeof(long)> t3;
 817     sa<sizeof(sink_4_2356(source()))    == 5 * sizeof(long)> t5;
 818     sa<sizeof(sink_4_2356(c_source()))  == 6 * sizeof(long)> t6;
 819     return 0;
 820 }
 821
 822 two   sink_4_2357(const          A&);
 823 three sink_4_2357(volatile       A&);
 824 five  sink_4_2357(               A&&);
 825 seven sink_4_2357(volatile       A&&);
 826
 827 int test4_2357()
 828 {
 829                    A a;
 830     const          A ca;
 831           volatile A va;
 832     const volatile A cva;
 833     sa<sizeof(sink_4_2357(ca))          == 2 * sizeof(long)> t2;
 834     sa<sizeof(sink_4_2357(va))          == 3 * sizeof(long)> t3;
 835     sa<sizeof(sink_4_2357(source()))    == 5 * sizeof(long)> t5;
 836     sa<sizeof(sink_4_2357(c_source()))  == 2 * sizeof(long)> t6;
 837     sa<sizeof(sink_4_2357(v_source()))  == 7 * sizeof(long)> t7;
 838     return 0;
 839 }
 840
 841 two   sink_4_2358(const          A&);
 842 three sink_4_2358(volatile       A&);
 843 five  sink_4_2358(               A&&);
 844 eight sink_4_2358(const volatile A&&);
 845
 846 int test4_2358()
 847 {
 848                    A a;
 849     const          A ca;
 850           volatile A va;
 851     const volatile A cva;
 852     sa<sizeof(sink_4_2358(ca))          == 2 * sizeof(long)> t2;
 853     sa<sizeof(sink_4_2358(va))          == 3 * sizeof(long)> t3;
 854     sa<sizeof(sink_4_2358(source()))    == 5 * sizeof(long)> t5;
 855     sa<sizeof(sink_4_2358(c_source()))  == 8 * sizeof(long)> t6;
 856     sa<sizeof(sink_4_2358(v_source()))  == 8 * sizeof(long)> t7;
 857     sa<sizeof(sink_4_2358(cv_source())) == 8 * sizeof(long)> t8;
 858     return 0;
 859 }
 860
 861 two   sink_4_2367(const          A&);
 862 three sink_4_2367(volatile       A&);
 863 six   sink_4_2367(const          A&&);
 864 seven sink_4_2367(volatile       A&&);
 865
 866 int test4_2367()
 867 {
 868                    A a;
 869     const          A ca;
 870           volatile A va;
 871     const volatile A cva;
 872     sa<sizeof(sink_4_2367(ca))          == 2 * sizeof(long)> t2;
 873     sa<sizeof(sink_4_2367(va))          == 3 * sizeof(long)> t3;
 874     sa<sizeof(sink_4_2367(c_source()))  == 6 * sizeof(long)> t6;
 875     sa<sizeof(sink_4_2367(v_source()))  == 7 * sizeof(long)> t7;
 876     return 0;
 877 }
 878
 879 two   sink_4_2368(const          A&);
 880 three sink_4_2368(volatile       A&);
 881 six   sink_4_2368(const          A&&);
 882 eight sink_4_2368(const volatile A&&);
 883
 884 int test4_2368()
 885 {
 886                    A a;
 887     const          A ca;
 888           volatile A va;
 889     const volatile A cva;
 890     sa<sizeof(sink_4_2368(ca))          == 2 * sizeof(long)> t2;
 891     sa<sizeof(sink_4_2368(va))          == 3 * sizeof(long)> t3;
 892     sa<sizeof(sink_4_2368(source()))    == 6 * sizeof(long)> t5;
 893     sa<sizeof(sink_4_2368(c_source()))  == 6 * sizeof(long)> t6;
 894     sa<sizeof(sink_4_2368(v_source()))  == 8 * sizeof(long)> t7;
 895     sa<sizeof(sink_4_2368(cv_source())) == 8 * sizeof(long)> t8;
 896     return 0;
 897 }
 898
 899 two   sink_4_2378(const          A&);
 900 three sink_4_2378(volatile       A&);
 901 seven sink_4_2378(volatile       A&&);
 902 eight sink_4_2378(const volatile A&&);
 903
 904 int test4_2378()
 905 {
 906                    A a;
 907     const          A ca;
 908           volatile A va;
 909     const volatile A cva;
 910     sa<sizeof(sink_4_2378(ca))          == 2 * sizeof(long)> t2;
 911     sa<sizeof(sink_4_2378(va))          == 3 * sizeof(long)> t3;
 912     sa<sizeof(sink_4_2378(source()))    == 7 * sizeof(long)> t5;
 913     sa<sizeof(sink_4_2378(c_source()))  == 8 * sizeof(long)> t6;
 914     sa<sizeof(sink_4_2378(v_source()))  == 7 * sizeof(long)> t7;
 915     sa<sizeof(sink_4_2378(cv_source())) == 8 * sizeof(long)> t8;
 916     return 0;
 917 }
 918
 919 two   sink_4_2456(const          A&);
 920 four  sink_4_2456(const volatile A&);
 921 five  sink_4_2456(               A&&);
 922 six   sink_4_2456(const          A&&);
 923
 924 int test4_2456()
 925 {
 926                    A a;
 927     const          A ca;
 928           volatile A va;
 929     const volatile A cva;
 930     sa<sizeof(sink_4_2456(a))           == 2 * sizeof(long)> t1;
 931     sa<sizeof(sink_4_2456(ca))          == 2 * sizeof(long)> t2;
 932     sa<sizeof(sink_4_2456(va))          == 4 * sizeof(long)> t3;
 933     sa<sizeof(sink_4_2456(cva))         == 4 * sizeof(long)> t4;
 934     sa<sizeof(sink_4_2456(source()))    == 5 * sizeof(long)> t5;
 935     sa<sizeof(sink_4_2456(c_source()))  == 6 * sizeof(long)> t6;
 936     return 0;
 937 }
 938
 939 two   sink_4_2457(const          A&);
 940 four  sink_4_2457(const volatile A&);
 941 five  sink_4_2457(               A&&);
 942 seven sink_4_2457(volatile       A&&);
 943
 944 int test4_2457()
 945 {
 946                    A a;
 947     const          A ca;
 948           volatile A va;
 949     const volatile A cva;
 950     sa<sizeof(sink_4_2457(a))           == 2 * sizeof(long)> t1;
 951     sa<sizeof(sink_4_2457(ca))          == 2 * sizeof(long)> t2;
 952     sa<sizeof(sink_4_2457(va))          == 4 * sizeof(long)> t3;
 953     sa<sizeof(sink_4_2457(cva))         == 4 * sizeof(long)> t4;
 954     sa<sizeof(sink_4_2457(source()))    == 5 * sizeof(long)> t5;
 955     sa<sizeof(sink_4_2457(c_source()))  == 2 * sizeof(long)> t6;
 956     sa<sizeof(sink_4_2457(v_source()))  == 7 * sizeof(long)> t7;
 957     return 0;
 958 }
 959
 960 two   sink_4_2458(const          A&);
 961 four  sink_4_2458(const volatile A&);
 962 five  sink_4_2458(               A&&);
 963 eight sink_4_2458(const volatile A&&);
 964
 965 int test4_2458()
 966 {
 967                    A a;
 968     const          A ca;
 969           volatile A va;
 970     const volatile A cva;
 971     sa<sizeof(sink_4_2458(a))           == 2 * sizeof(long)> t1;
 972     sa<sizeof(sink_4_2458(ca))          == 2 * sizeof(long)> t2;
 973     sa<sizeof(sink_4_2458(va))          == 4 * sizeof(long)> t3;
 974     sa<sizeof(sink_4_2458(cva))         == 4 * sizeof(long)> t4;
 975     sa<sizeof(sink_4_2458(source()))    == 5 * sizeof(long)> t5;
 976     sa<sizeof(sink_4_2458(c_source()))  == 8 * sizeof(long)> t6;
 977     sa<sizeof(sink_4_2458(v_source()))  == 8 * sizeof(long)> t7;
 978     sa<sizeof(sink_4_2458(cv_source())) == 8 * sizeof(long)> t8;
 979     return 0;
 980 }
 981
 982 two   sink_4_2467(const          A&);
 983 four  sink_4_2467(const volatile A&);
 984 six   sink_4_2467(const          A&&);
 985 seven sink_4_2467(volatile       A&&);
 986
 987 int test4_2467()
 988 {
 989                    A a;
 990     const          A ca;
 991           volatile A va;
 992     const volatile A cva;
 993     sa<sizeof(sink_4_2467(a))           == 2 * sizeof(long)> t1;
 994     sa<sizeof(sink_4_2467(ca))          == 2 * sizeof(long)> t2;
 995     sa<sizeof(sink_4_2467(va))          == 4 * sizeof(long)> t3;
 996     sa<sizeof(sink_4_2467(cva))         == 4 * sizeof(long)> t4;
 997     sa<sizeof(sink_4_2467(c_source()))  == 6 * sizeof(long)> t6;
 998     sa<sizeof(sink_4_2467(v_source()))  == 7 * sizeof(long)> t7;
 999     return 0;
1000 }
1001
1002 two   sink_4_2468(const          A&);
1003 four  sink_4_2468(const volatile A&);
1004 six   sink_4_2468(const          A&&);
1005 eight sink_4_2468(const volatile A&&);
1006
1007 int test4_2468()
1008 {
1009                    A a;
1010     const          A ca;
1011           volatile A va;
1012     const volatile A cva;
1013     sa<sizeof(sink_4_2468(a))           == 2 * sizeof(long)> t1;
1014     sa<sizeof(sink_4_2468(ca))          == 2 * sizeof(long)> t2;
1015     sa<sizeof(sink_4_2468(va))          == 4 * sizeof(long)> t3;
1016     sa<sizeof(sink_4_2468(cva))         == 4 * sizeof(long)> t4;
1017     sa<sizeof(sink_4_2468(source()))    == 6 * sizeof(long)> t5;
1018     sa<sizeof(sink_4_2468(c_source()))  == 6 * sizeof(long)> t6;
1019     sa<sizeof(sink_4_2468(v_source()))  == 8 * sizeof(long)> t7;
1020     sa<sizeof(sink_4_2468(cv_source())) == 8 * sizeof(long)> t8;
1021     return 0;
1022 }
1023
1024 two   sink_4_2478(const          A&);
1025 four  sink_4_2478(const volatile A&);
1026 seven sink_4_2478(volatile       A&&);
1027 eight sink_4_2478(const volatile A&&);
1028
1029 int test4_2478()
1030 {
1031                    A a;
1032     const          A ca;
1033           volatile A va;
1034     const volatile A cva;
1035     sa<sizeof(sink_4_2478(a))           == 2 * sizeof(long)> t1;
1036     sa<sizeof(sink_4_2478(ca))          == 2 * sizeof(long)> t2;
1037     sa<sizeof(sink_4_2478(va))          == 4 * sizeof(long)> t3;
1038     sa<sizeof(sink_4_2478(cva))         == 4 * sizeof(long)> t4;
1039     sa<sizeof(sink_4_2478(source()))    == 7 * sizeof(long)> t5;
1040     sa<sizeof(sink_4_2478(c_source()))  == 8 * sizeof(long)> t6;
1041     sa<sizeof(sink_4_2478(v_source()))  == 7 * sizeof(long)> t7;
1042     sa<sizeof(sink_4_2478(cv_source())) == 8 * sizeof(long)> t8;
1043     return 0;
1044 }
1045
1046 two   sink_4_2567(const          A&);
1047 five  sink_4_2567(               A&&);
1048 six   sink_4_2567(const          A&&);
1049 seven sink_4_2567(volatile       A&&);
1050
1051 int test4_2567()
1052 {
1053                    A a;
1054     const          A ca;
1055           volatile A va;
1056     const volatile A cva;
1057     sa<sizeof(sink_4_2567(a))           == 2 * sizeof(long)> t1;
1058     sa<sizeof(sink_4_2567(ca))          == 2 * sizeof(long)> t2;
1059     sa<sizeof(sink_4_2567(source()))    == 5 * sizeof(long)> t5;
1060     sa<sizeof(sink_4_2567(c_source()))  == 6 * sizeof(long)> t6;
1061     sa<sizeof(sink_4_2567(v_source()))  == 7 * sizeof(long)> t7;
1062     return 0;
1063 }
1064
1065 two   sink_4_2568(const          A&);
1066 five  sink_4_2568(               A&&);
1067 six   sink_4_2568(const          A&&);
1068 eight sink_4_2568(const volatile A&&);
1069
1070 int test4_2568()
1071 {
1072                    A a;
1073     const          A ca;
1074           volatile A va;
1075     const volatile A cva;
1076     sa<sizeof(sink_4_2568(a))           == 2 * sizeof(long)> t1;
1077     sa<sizeof(sink_4_2568(ca))          == 2 * sizeof(long)> t2;
1078     sa<sizeof(sink_4_2568(source()))    == 5 * sizeof(long)> t5;
1079     sa<sizeof(sink_4_2568(c_source()))  == 6 * sizeof(long)> t6;
1080     sa<sizeof(sink_4_2568(v_source()))  == 8 * sizeof(long)> t7;
1081     sa<sizeof(sink_4_2568(cv_source())) == 8 * sizeof(long)> t8;
1082     return 0;
1083 }
1084
1085 two   sink_4_2578(const          A&);
1086 five  sink_4_2578(               A&&);
1087 seven sink_4_2578(volatile       A&&);
1088 eight sink_4_2578(const volatile A&&);
1089
1090 int test4_2578()
1091 {
1092                    A a;
1093     const          A ca;
1094           volatile A va;
1095     const volatile A cva;
1096     sa<sizeof(sink_4_2578(a))           == 2 * sizeof(long)> t1;
1097     sa<sizeof(sink_4_2578(ca))          == 2 * sizeof(long)> t2;
1098     sa<sizeof(sink_4_2578(source()))    == 5 * sizeof(long)> t5;
1099     sa<sizeof(sink_4_2578(c_source()))  == 8 * sizeof(long)> t6;
1100     sa<sizeof(sink_4_2578(v_source()))  == 7 * sizeof(long)> t7;
1101     sa<sizeof(sink_4_2578(cv_source())) == 8 * sizeof(long)> t8;
1102     return 0;
1103 }
1104
1105 two   sink_4_2678(const          A&);
1106 six   sink_4_2678(const          A&&);
1107 seven sink_4_2678(volatile       A&&);
1108 eight sink_4_2678(const volatile A&&);
1109
1110 int test4_2678()
1111 {
1112                    A a;
1113     const          A ca;
1114           volatile A va;
1115     const volatile A cva;
1116     sa<sizeof(sink_4_2678(a))           == 2 * sizeof(long)> t1;
1117     sa<sizeof(sink_4_2678(ca))          == 2 * sizeof(long)> t2;
1118     sa<sizeof(sink_4_2678(c_source()))  == 6 * sizeof(long)> t6;
1119     sa<sizeof(sink_4_2678(v_source()))  == 7 * sizeof(long)> t7;
1120     sa<sizeof(sink_4_2678(cv_source())) == 8 * sizeof(long)> t8;
1121     return 0;
1122 }
1123
1124 three sink_4_3456(volatile       A&);
1125 four  sink_4_3456(const volatile A&);
1126 five  sink_4_3456(               A&&);
1127 six   sink_4_3456(const          A&&);
1128
1129 int test4_3456()
1130 {
1131                    A a;
1132     const          A ca;
1133           volatile A va;
1134     const volatile A cva;
1135     sa<sizeof(sink_4_3456(a))           == 3 * sizeof(long)> t1;
1136     sa<sizeof(sink_4_3456(ca))          == 4 * sizeof(long)> t2;
1137     sa<sizeof(sink_4_3456(va))          == 3 * sizeof(long)> t3;
1138     sa<sizeof(sink_4_3456(cva))         == 4 * sizeof(long)> t4;
1139     sa<sizeof(sink_4_3456(source()))    == 5 * sizeof(long)> t5;
1140     sa<sizeof(sink_4_3456(c_source()))  == 6 * sizeof(long)> t6;
1141     return 0;
1142 }
1143
1144 three sink_4_3457(volatile       A&);
1145 four  sink_4_3457(const volatile A&);
1146 five  sink_4_3457(               A&&);
1147 seven sink_4_3457(volatile       A&&);
1148
1149 int test4_3457()
1150 {
1151                    A a;
1152     const          A ca;
1153           volatile A va;
1154     const volatile A cva;
1155     sa<sizeof(sink_4_3457(a))           == 3 * sizeof(long)> t1;
1156     sa<sizeof(sink_4_3457(ca))          == 4 * sizeof(long)> t2;
1157     sa<sizeof(sink_4_3457(va))          == 3 * sizeof(long)> t3;
1158     sa<sizeof(sink_4_3457(cva))         == 4 * sizeof(long)> t4;
1159     sa<sizeof(sink_4_3457(source()))    == 5 * sizeof(long)> t5;
1160     sa<sizeof(sink_4_3457(v_source()))  == 7 * sizeof(long)> t7;
1161     return 0;
1162 }
1163
1164 three sink_4_3458(volatile       A&);
1165 four  sink_4_3458(const volatile A&);
1166 five  sink_4_3458(               A&&);
1167 eight sink_4_3458(const volatile A&&);
1168
1169 int test4_3458()
1170 {
1171                    A a;
1172     const          A ca;
1173           volatile A va;
1174     const volatile A cva;
1175     sa<sizeof(sink_4_3458(a))           == 3 * sizeof(long)> t1;
1176     sa<sizeof(sink_4_3458(ca))          == 4 * sizeof(long)> t2;
1177     sa<sizeof(sink_4_3458(va))          == 3 * sizeof(long)> t3;
1178     sa<sizeof(sink_4_3458(cva))         == 4 * sizeof(long)> t4;
1179     sa<sizeof(sink_4_3458(source()))    == 5 * sizeof(long)> t5;
1180     sa<sizeof(sink_4_3458(c_source()))  == 8 * sizeof(long)> t6;
1181     sa<sizeof(sink_4_3458(v_source()))  == 8 * sizeof(long)> t7;
1182     sa<sizeof(sink_4_3458(cv_source())) == 8 * sizeof(long)> t8;
1183     return 0;
1184 }
1185
1186 three sink_4_3467(volatile       A&);
1187 four  sink_4_3467(const volatile A&);
1188 six   sink_4_3467(const          A&&);
1189 seven sink_4_3467(volatile       A&&);
1190
1191 int test4_3467()
1192 {
1193                    A a;
1194     const          A ca;
1195           volatile A va;
1196     const volatile A cva;
1197     sa<sizeof(sink_4_3467(a))           == 3 * sizeof(long)> t1;
1198     sa<sizeof(sink_4_3467(ca))          == 4 * sizeof(long)> t2;
1199     sa<sizeof(sink_4_3467(va))          == 3 * sizeof(long)> t3;
1200     sa<sizeof(sink_4_3467(cva))         == 4 * sizeof(long)> t4;
1201     sa<sizeof(sink_4_3467(c_source()))  == 6 * sizeof(long)> t6;
1202     sa<sizeof(sink_4_3467(v_source()))  == 7 * sizeof(long)> t7;
1203     return 0;
1204 }
1205
1206 three sink_4_3468(volatile       A&);
1207 four  sink_4_3468(const volatile A&);
1208 six   sink_4_3468(const          A&&);
1209 eight sink_4_3468(const volatile A&&);
1210
1211 int test4_3468()
1212 {
1213                    A a;
1214     const          A ca;
1215           volatile A va;
1216     const volatile A cva;
1217     sa<sizeof(sink_4_3468(a))           == 3 * sizeof(long)> t1;
1218     sa<sizeof(sink_4_3468(ca))          == 4 * sizeof(long)> t2;
1219     sa<sizeof(sink_4_3468(va))          == 3 * sizeof(long)> t3;
1220     sa<sizeof(sink_4_3468(cva))         == 4 * sizeof(long)> t4;
1221     sa<sizeof(sink_4_3468(source()))    == 6 * sizeof(long)> t5;
1222     sa<sizeof(sink_4_3468(c_source()))  == 6 * sizeof(long)> t6;
1223     sa<sizeof(sink_4_3468(v_source()))  == 8 * sizeof(long)> t7;
1224     sa<sizeof(sink_4_3468(cv_source())) == 8 * sizeof(long)> t8;
1225     return 0;
1226 }
1227
1228 three sink_4_3478(volatile       A&);
1229 four  sink_4_3478(const volatile A&);
1230 seven sink_4_3478(volatile       A&&);
1231 eight sink_4_3478(const volatile A&&);
1232
1233 int test4_3478()
1234 {
1235                    A a;
1236     const          A ca;
1237           volatile A va;
1238     const volatile A cva;
1239     sa<sizeof(sink_4_3478(a))           == 3 * sizeof(long)> t1;
1240     sa<sizeof(sink_4_3478(ca))          == 4 * sizeof(long)> t2;
1241     sa<sizeof(sink_4_3478(va))          == 3 * sizeof(long)> t3;
1242     sa<sizeof(sink_4_3478(cva))         == 4 * sizeof(long)> t4;
1243     sa<sizeof(sink_4_3478(source()))    == 7 * sizeof(long)> t5;
1244     sa<sizeof(sink_4_3478(c_source()))  == 8 * sizeof(long)> t6;
1245     sa<sizeof(sink_4_3478(v_source()))  == 7 * sizeof(long)> t7;
1246     sa<sizeof(sink_4_3478(cv_source())) == 8 * sizeof(long)> t8;
1247     return 0;
1248 }
1249
1250 three sink_4_3567(volatile       A&);
1251 five  sink_4_3567(               A&&);
1252 six   sink_4_3567(const          A&&);
1253 seven sink_4_3567(volatile       A&&);
1254
1255 int test4_3567()
1256 {
1257                    A a;
1258     const          A ca;
1259           volatile A va;
1260     const volatile A cva;
1261     sa<sizeof(sink_4_3567(a))           == 3 * sizeof(long)> t1;
1262     sa<sizeof(sink_4_3567(va))          == 3 * sizeof(long)> t3;
1263     sa<sizeof(sink_4_3567(source()))    == 5 * sizeof(long)> t5;
1264     sa<sizeof(sink_4_3567(c_source()))  == 6 * sizeof(long)> t6;
1265     sa<sizeof(sink_4_3567(v_source()))  == 7 * sizeof(long)> t7;
1266     return 0;
1267 }
1268
1269 three sink_4_3568(volatile       A&);
1270 five  sink_4_3568(               A&&);
1271 six   sink_4_3568(const          A&&);
1272 eight sink_4_3568(const volatile A&&);
1273
1274 int test4_3568()
1275 {
1276                    A a;
1277     const          A ca;
1278           volatile A va;
1279     const volatile A cva;
1280     sa<sizeof(sink_4_3568(a))           == 3 * sizeof(long)> t1;
1281     sa<sizeof(sink_4_3568(va))          == 3 * sizeof(long)> t3;
1282     sa<sizeof(sink_4_3568(source()))    == 5 * sizeof(long)> t5;
1283     sa<sizeof(sink_4_3568(c_source()))  == 6 * sizeof(long)> t6;
1284     sa<sizeof(sink_4_3568(v_source()))  == 8 * sizeof(long)> t7;
1285     sa<sizeof(sink_4_3568(cv_source())) == 8 * sizeof(long)> t8;
1286     return 0;
1287 }
1288
1289 three sink_4_3578(volatile       A&);
1290 five  sink_4_3578(               A&&);
1291 seven sink_4_3578(volatile       A&&);
1292 eight sink_4_3578(const volatile A&&);
1293
1294 int test4_3578()
1295 {
1296                    A a;
1297     const          A ca;
1298           volatile A va;
1299     const volatile A cva;
1300     sa<sizeof(sink_4_3578(a))           == 3 * sizeof(long)> t1;
1301     sa<sizeof(sink_4_3578(va))          == 3 * sizeof(long)> t3;
1302     sa<sizeof(sink_4_3578(source()))    == 5 * sizeof(long)> t5;
1303     sa<sizeof(sink_4_3578(c_source()))  == 8 * sizeof(long)> t6;
1304     sa<sizeof(sink_4_3578(v_source()))  == 7 * sizeof(long)> t7;
1305     sa<sizeof(sink_4_3578(cv_source())) == 8 * sizeof(long)> t8;
1306     return 0;
1307 }
1308
1309 three sink_4_3678(volatile       A&);
1310 six   sink_4_3678(const          A&&);
1311 seven sink_4_3678(volatile       A&&);
1312 eight sink_4_3678(const volatile A&&);
1313
1314 int test4_3678()
1315 {
1316                    A a;
1317     const          A ca;
1318           volatile A va;
1319     const volatile A cva;
1320     sa<sizeof(sink_4_3678(a))           == 3 * sizeof(long)> t1;
1321     sa<sizeof(sink_4_3678(va))          == 3 * sizeof(long)> t3;
1322     sa<sizeof(sink_4_3678(c_source()))  == 6 * sizeof(long)> t6;
1323     sa<sizeof(sink_4_3678(v_source()))  == 7 * sizeof(long)> t7;
1324     sa<sizeof(sink_4_3678(cv_source())) == 8 * sizeof(long)> t8;
1325     return 0;
1326 }
1327
1328 four  sink_4_4567(const volatile A&);
1329 five  sink_4_4567(               A&&);
1330 six   sink_4_4567(const          A&&);
1331 seven sink_4_4567(volatile       A&&);
1332
1333 int test4_4567()
1334 {
1335                    A a;
1336     const          A ca;
1337           volatile A va;
1338     const volatile A cva;
1339     sa<sizeof(sink_4_4567(a))           == 4 * sizeof(long)> t1;
1340     sa<sizeof(sink_4_4567(ca))          == 4 * sizeof(long)> t2;
1341     sa<sizeof(sink_4_4567(va))          == 4 * sizeof(long)> t3;
1342     sa<sizeof(sink_4_4567(cva))         == 4 * sizeof(long)> t4;
1343     sa<sizeof(sink_4_4567(source()))    == 5 * sizeof(long)> t5;
1344     sa<sizeof(sink_4_4567(c_source()))  == 6 * sizeof(long)> t6;
1345     sa<sizeof(sink_4_4567(v_source()))  == 7 * sizeof(long)> t7;
1346     return 0;
1347 }
1348
1349 four  sink_4_4568(const volatile A&);
1350 five  sink_4_4568(               A&&);
1351 six   sink_4_4568(const          A&&);
1352 eight sink_4_4568(const volatile A&&);
1353
1354 int test4_4568()
1355 {
1356                    A a;
1357     const          A ca;
1358           volatile A va;
1359     const volatile A cva;
1360     sa<sizeof(sink_4_4568(a))           == 4 * sizeof(long)> t1;
1361     sa<sizeof(sink_4_4568(ca))          == 4 * sizeof(long)> t2;
1362     sa<sizeof(sink_4_4568(va))          == 4 * sizeof(long)> t3;
1363     sa<sizeof(sink_4_4568(cva))         == 4 * sizeof(long)> t4;
1364     sa<sizeof(sink_4_4568(source()))    == 5 * sizeof(long)> t5;
1365     sa<sizeof(sink_4_4568(c_source()))  == 6 * sizeof(long)> t6;
1366     sa<sizeof(sink_4_4568(v_source()))  == 8 * sizeof(long)> t7;
1367     sa<sizeof(sink_4_4568(cv_source())) == 8 * sizeof(long)> t8;
1368     return 0;
1369 }
1370
1371 four  sink_4_4578(const volatile A&);
1372 five  sink_4_4578(               A&&);
1373 seven sink_4_4578(volatile       A&&);
1374 eight sink_4_4578(const volatile A&&);
1375
1376 int test4_4578()
1377 {
1378                    A a;
1379     const          A ca;
1380           volatile A va;
1381     const volatile A cva;
1382     sa<sizeof(sink_4_4578(a))           == 4 * sizeof(long)> t1;
1383     sa<sizeof(sink_4_4578(ca))          == 4 * sizeof(long)> t2;
1384     sa<sizeof(sink_4_4578(va))          == 4 * sizeof(long)> t3;
1385     sa<sizeof(sink_4_4578(cva))         == 4 * sizeof(long)> t4;
1386     sa<sizeof(sink_4_4578(source()))    == 5 * sizeof(long)> t5;
1387     sa<sizeof(sink_4_4578(c_source()))  == 8 * sizeof(long)> t6;
1388     sa<sizeof(sink_4_4578(v_source()))  == 7 * sizeof(long)> t7;
1389     sa<sizeof(sink_4_4578(cv_source())) == 8 * sizeof(long)> t8;
1390     return 0;
1391 }
1392
1393 four  sink_4_4678(const volatile A&);
1394 six   sink_4_4678(const          A&&);
1395 seven sink_4_4678(volatile       A&&);
1396 eight sink_4_4678(const volatile A&&);
1397
1398 int test4_4678()
1399 {
1400                    A a;
1401     const          A ca;
1402           volatile A va;
1403     const volatile A cva;
1404     sa<sizeof(sink_4_4678(a))           == 4 * sizeof(long)> t1;
1405     sa<sizeof(sink_4_4678(ca))          == 4 * sizeof(long)> t2;
1406     sa<sizeof(sink_4_4678(va))          == 4 * sizeof(long)> t3;
1407     sa<sizeof(sink_4_4678(cva))         == 4 * sizeof(long)> t4;
1408     sa<sizeof(sink_4_4678(c_source()))  == 6 * sizeof(long)> t6;
1409     sa<sizeof(sink_4_4678(v_source()))  == 7 * sizeof(long)> t7;
1410     sa<sizeof(sink_4_4678(cv_source())) == 8 * sizeof(long)> t8;
1411     return 0;
1412 }
1413
1414 five  sink_4_5678(               A&&);
1415 six   sink_4_5678(const          A&&);
1416 seven sink_4_5678(volatile       A&&);
1417 eight sink_4_5678(const volatile A&&);
1418
1419 int test4_5678()
1420 {
1421                    A a;
1422     const          A ca;
1423           volatile A va;
1424     const volatile A cva;
1425     sa<sizeof(sink_4_5678(source()))    == 5 * sizeof(long)> t5;
1426     sa<sizeof(sink_4_5678(c_source()))  == 6 * sizeof(long)> t6;
1427     sa<sizeof(sink_4_5678(v_source()))  == 7 * sizeof(long)> t7;
1428     sa<sizeof(sink_4_5678(cv_source())) == 8 * sizeof(long)> t8;
1429     return 0;
1430 }
1431
1432 int main()
1433 {
1434     return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() +
1435            test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() +
1436            test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() +
1437            test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() +
1438            test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() +
1439            test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() +
1440            test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() +
1441            test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() +
1442            test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() +
1443            test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() +
1444            test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() +
1445            test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() +
1446            test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() +
1447            test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678();
1448 }