gcc/testsuite/g++.dg/cpp0x/rv6p.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 { 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 // 6 at a time
  32
  33 one   sink_6_123456(               A&);
  34 two   sink_6_123456(const          A&);
  35 three sink_6_123456(volatile       A&);
  36 four  sink_6_123456(const volatile A&);
  37 five  sink_6_123456(               A&&);
  38 six   sink_6_123456(const          A&&);
  39
  40 int test6_123456()
  41 {
  42                    A a;
  43     const          A ca;
  44           volatile A va;
  45     const volatile A cva;
  46     sa<sizeof(sink_6_123456(a))           == 1 * sizeof(long)> t1;
  47     sa<sizeof(sink_6_123456(ca))          == 2 * sizeof(long)> t2;
  48     sa<sizeof(sink_6_123456(va))          == 3 * sizeof(long)> t3;
  49     sa<sizeof(sink_6_123456(cva))         == 4 * sizeof(long)> t4;
  50     sa<sizeof(sink_6_123456(source()))    == 5 * sizeof(long)> t5;
  51     sa<sizeof(sink_6_123456(c_source()))  == 6 * sizeof(long)> t6;
  52     return 0;
  53 }
  54
  55 one   sink_6_123457(               A&);
  56 two   sink_6_123457(const          A&);
  57 three sink_6_123457(volatile       A&);
  58 four  sink_6_123457(const volatile A&);
  59 five  sink_6_123457(               A&&);
  60 seven sink_6_123457(volatile       A&&);
  61
  62 int test6_123457()
  63 {
  64                    A a;
  65     const          A ca;
  66           volatile A va;
  67     const volatile A cva;
  68     sa<sizeof(sink_6_123457(a))           == 1 * sizeof(long)> t1;
  69     sa<sizeof(sink_6_123457(ca))          == 2 * sizeof(long)> t2;
  70     sa<sizeof(sink_6_123457(va))          == 3 * sizeof(long)> t3;
  71     sa<sizeof(sink_6_123457(cva))         == 4 * sizeof(long)> t4;
  72     sa<sizeof(sink_6_123457(source()))    == 5 * sizeof(long)> t5;
  73     sa<sizeof(sink_6_123457(c_source()))  == 2 * sizeof(long)> t6;
  74     sa<sizeof(sink_6_123457(v_source()))  == 7 * sizeof(long)> t7;
  75     return 0;
  76 }
  77
  78 one   sink_6_123458(               A&);
  79 two   sink_6_123458(const          A&);
  80 three sink_6_123458(volatile       A&);
  81 four  sink_6_123458(const volatile A&);
  82 five  sink_6_123458(               A&&);
  83 eight sink_6_123458(const volatile A&&);
  84
  85 int test6_123458()
  86 {
  87                    A a;
  88     const          A ca;
  89           volatile A va;
  90     const volatile A cva;
  91     sa<sizeof(sink_6_123458(a))           == 1 * sizeof(long)> t1;
  92     sa<sizeof(sink_6_123458(ca))          == 2 * sizeof(long)> t2;
  93     sa<sizeof(sink_6_123458(va))          == 3 * sizeof(long)> t3;
  94     sa<sizeof(sink_6_123458(cva))         == 4 * sizeof(long)> t4;
  95     sa<sizeof(sink_6_123458(source()))    == 5 * sizeof(long)> t5;
  96     sa<sizeof(sink_6_123458(c_source()))  == 8 * sizeof(long)> t6;
  97     sa<sizeof(sink_6_123458(v_source()))  == 8 * sizeof(long)> t7;
  98     sa<sizeof(sink_6_123458(cv_source())) == 8 * sizeof(long)> t8;
  99     return 0;
 100 }
 101
 102 one   sink_6_123467(               A&);
 103 two   sink_6_123467(const          A&);
 104 three sink_6_123467(volatile       A&);
 105 four  sink_6_123467(const volatile A&);
 106 six   sink_6_123467(const          A&&);
 107 seven sink_6_123467(volatile       A&&);
 108
 109 int test6_123467()
 110 {
 111                    A a;
 112     const          A ca;
 113           volatile A va;
 114     const volatile A cva;
 115     sa<sizeof(sink_6_123467(a))           == 1 * sizeof(long)> t1;
 116     sa<sizeof(sink_6_123467(ca))          == 2 * sizeof(long)> t2;
 117     sa<sizeof(sink_6_123467(va))          == 3 * sizeof(long)> t3;
 118     sa<sizeof(sink_6_123467(cva))         == 4 * sizeof(long)> t4;
 119     sa<sizeof(sink_6_123467(c_source()))  == 6 * sizeof(long)> t6;
 120     sa<sizeof(sink_6_123467(v_source()))  == 7 * sizeof(long)> t7;
 121     return 0;
 122 }
 123
 124 one   sink_6_123468(               A&);
 125 two   sink_6_123468(const          A&);
 126 three sink_6_123468(volatile       A&);
 127 four  sink_6_123468(const volatile A&);
 128 six   sink_6_123468(const          A&&);
 129 eight sink_6_123468(const volatile A&&);
 130
 131 int test6_123468()
 132 {
 133                    A a;
 134     const          A ca;
 135           volatile A va;
 136     const volatile A cva;
 137     sa<sizeof(sink_6_123468(a))           == 1 * sizeof(long)> t1;
 138     sa<sizeof(sink_6_123468(ca))          == 2 * sizeof(long)> t2;
 139     sa<sizeof(sink_6_123468(va))          == 3 * sizeof(long)> t3;
 140     sa<sizeof(sink_6_123468(cva))         == 4 * sizeof(long)> t4;
 141     sa<sizeof(sink_6_123468(source()))    == 6 * sizeof(long)> t5;
 142     sa<sizeof(sink_6_123468(c_source()))  == 6 * sizeof(long)> t6;
 143     sa<sizeof(sink_6_123468(v_source()))  == 8 * sizeof(long)> t7;
 144     sa<sizeof(sink_6_123468(cv_source())) == 8 * sizeof(long)> t8;
 145     return 0;
 146 }
 147
 148 one   sink_6_123478(               A&);
 149 two   sink_6_123478(const          A&);
 150 three sink_6_123478(volatile       A&);
 151 four  sink_6_123478(const volatile A&);
 152 seven sink_6_123478(volatile       A&&);
 153 eight sink_6_123478(const volatile A&&);
 154
 155 int test6_123478()
 156 {
 157                    A a;
 158     const          A ca;
 159           volatile A va;
 160     const volatile A cva;
 161     sa<sizeof(sink_6_123478(a))           == 1 * sizeof(long)> t1;
 162     sa<sizeof(sink_6_123478(ca))          == 2 * sizeof(long)> t2;
 163     sa<sizeof(sink_6_123478(va))          == 3 * sizeof(long)> t3;
 164     sa<sizeof(sink_6_123478(cva))         == 4 * sizeof(long)> t4;
 165     sa<sizeof(sink_6_123478(source()))    == 7 * sizeof(long)> t5;
 166     sa<sizeof(sink_6_123478(c_source()))  == 8 * sizeof(long)> t6;
 167     sa<sizeof(sink_6_123478(v_source()))  == 7 * sizeof(long)> t7;
 168     sa<sizeof(sink_6_123478(cv_source())) == 8 * sizeof(long)> t8;
 169     return 0;
 170 }
 171
 172 one   sink_6_123567(               A&);
 173 two   sink_6_123567(const          A&);
 174 three sink_6_123567(volatile       A&);
 175 five  sink_6_123567(               A&&);
 176 six   sink_6_123567(const          A&&);
 177 seven sink_6_123567(volatile       A&&);
 178
 179 int test6_123567()
 180 {
 181                    A a;
 182     const          A ca;
 183           volatile A va;
 184     const volatile A cva;
 185     sa<sizeof(sink_6_123567(a))           == 1 * sizeof(long)> t1;
 186     sa<sizeof(sink_6_123567(ca))          == 2 * sizeof(long)> t2;
 187     sa<sizeof(sink_6_123567(va))          == 3 * sizeof(long)> t3;
 188     sa<sizeof(sink_6_123567(source()))    == 5 * sizeof(long)> t5;
 189     sa<sizeof(sink_6_123567(c_source()))  == 6 * sizeof(long)> t6;
 190     sa<sizeof(sink_6_123567(v_source()))  == 7 * sizeof(long)> t7;
 191     return 0;
 192 }
 193
 194 one   sink_6_123568(               A&);
 195 two   sink_6_123568(const          A&);
 196 three sink_6_123568(volatile       A&);
 197 five  sink_6_123568(               A&&);
 198 six   sink_6_123568(const          A&&);
 199 eight sink_6_123568(const volatile A&&);
 200
 201 int test6_123568()
 202 {
 203                    A a;
 204     const          A ca;
 205           volatile A va;
 206     const volatile A cva;
 207     sa<sizeof(sink_6_123568(a))           == 1 * sizeof(long)> t1;
 208     sa<sizeof(sink_6_123568(ca))          == 2 * sizeof(long)> t2;
 209     sa<sizeof(sink_6_123568(va))          == 3 * sizeof(long)> t3;
 210     sa<sizeof(sink_6_123568(source()))    == 5 * sizeof(long)> t5;
 211     sa<sizeof(sink_6_123568(c_source()))  == 6 * sizeof(long)> t6;
 212     sa<sizeof(sink_6_123568(v_source()))  == 8 * sizeof(long)> t7;
 213     sa<sizeof(sink_6_123568(cv_source())) == 8 * sizeof(long)> t8;
 214     return 0;
 215 }
 216
 217 one   sink_6_123578(               A&);
 218 two   sink_6_123578(const          A&);
 219 three sink_6_123578(volatile       A&);
 220 five  sink_6_123578(               A&&);
 221 seven sink_6_123578(volatile       A&&);
 222 eight sink_6_123578(const volatile A&&);
 223
 224 int test6_123578()
 225 {
 226                    A a;
 227     const          A ca;
 228           volatile A va;
 229     const volatile A cva;
 230     sa<sizeof(sink_6_123578(a))           == 1 * sizeof(long)> t1;
 231     sa<sizeof(sink_6_123578(ca))          == 2 * sizeof(long)> t2;
 232     sa<sizeof(sink_6_123578(va))          == 3 * sizeof(long)> t3;
 233     sa<sizeof(sink_6_123578(source()))    == 5 * sizeof(long)> t5;
 234     sa<sizeof(sink_6_123578(c_source()))  == 8 * sizeof(long)> t6;
 235     sa<sizeof(sink_6_123578(v_source()))  == 7 * sizeof(long)> t7;
 236     sa<sizeof(sink_6_123578(cv_source())) == 8 * sizeof(long)> t8;
 237     return 0;
 238 }
 239
 240 one   sink_6_123678(               A&);
 241 two   sink_6_123678(const          A&);
 242 three sink_6_123678(volatile       A&);
 243 six   sink_6_123678(const          A&&);
 244 seven sink_6_123678(volatile       A&&);
 245 eight sink_6_123678(const volatile A&&);
 246
 247 int test6_123678()
 248 {
 249                    A a;
 250     const          A ca;
 251           volatile A va;
 252     const volatile A cva;
 253     sa<sizeof(sink_6_123678(a))           == 1 * sizeof(long)> t1;
 254     sa<sizeof(sink_6_123678(ca))          == 2 * sizeof(long)> t2;
 255     sa<sizeof(sink_6_123678(va))          == 3 * sizeof(long)> t3;
 256     sa<sizeof(sink_6_123678(c_source()))  == 6 * sizeof(long)> t6;
 257     sa<sizeof(sink_6_123678(v_source()))  == 7 * sizeof(long)> t7;
 258     sa<sizeof(sink_6_123678(cv_source())) == 8 * sizeof(long)> t8;
 259     return 0;
 260 }
 261
 262 one   sink_6_124567(               A&);
 263 two   sink_6_124567(const          A&);
 264 four  sink_6_124567(const volatile A&);
 265 five  sink_6_124567(               A&&);
 266 six   sink_6_124567(const          A&&);
 267 seven sink_6_124567(volatile       A&&);
 268
 269 int test6_124567()
 270 {
 271                    A a;
 272     const          A ca;
 273           volatile A va;
 274     const volatile A cva;
 275     sa<sizeof(sink_6_124567(a))           == 1 * sizeof(long)> t1;
 276     sa<sizeof(sink_6_124567(ca))          == 2 * sizeof(long)> t2;
 277     sa<sizeof(sink_6_124567(va))          == 4 * sizeof(long)> t3;
 278     sa<sizeof(sink_6_124567(cva))         == 4 * sizeof(long)> t4;
 279     sa<sizeof(sink_6_124567(source()))    == 5 * sizeof(long)> t5;
 280     sa<sizeof(sink_6_124567(c_source()))  == 6 * sizeof(long)> t6;
 281     sa<sizeof(sink_6_124567(v_source()))  == 7 * sizeof(long)> t7;
 282     return 0;
 283 }
 284
 285 one   sink_6_124568(               A&);
 286 two   sink_6_124568(const          A&);
 287 four  sink_6_124568(const volatile A&);
 288 five  sink_6_124568(               A&&);
 289 six   sink_6_124568(const          A&&);
 290 eight sink_6_124568(const volatile A&&);
 291
 292 int test6_124568()
 293 {
 294                    A a;
 295     const          A ca;
 296           volatile A va;
 297     const volatile A cva;
 298     sa<sizeof(sink_6_124568(a))           == 1 * sizeof(long)> t1;
 299     sa<sizeof(sink_6_124568(ca))          == 2 * sizeof(long)> t2;
 300     sa<sizeof(sink_6_124568(va))          == 4 * sizeof(long)> t3;
 301     sa<sizeof(sink_6_124568(cva))         == 4 * sizeof(long)> t4;
 302     sa<sizeof(sink_6_124568(source()))    == 5 * sizeof(long)> t5;
 303     sa<sizeof(sink_6_124568(c_source()))  == 6 * sizeof(long)> t6;
 304     sa<sizeof(sink_6_124568(v_source()))  == 8 * sizeof(long)> t7;
 305     sa<sizeof(sink_6_124568(cv_source())) == 8 * sizeof(long)> t8;
 306     return 0;
 307 }
 308
 309 one   sink_6_124578(               A&);
 310 two   sink_6_124578(const          A&);
 311 four  sink_6_124578(const volatile A&);
 312 five  sink_6_124578(               A&&);
 313 seven sink_6_124578(volatile       A&&);
 314 eight sink_6_124578(const volatile A&&);
 315
 316 int test6_124578()
 317 {
 318                    A a;
 319     const          A ca;
 320           volatile A va;
 321     const volatile A cva;
 322     sa<sizeof(sink_6_124578(a))           == 1 * sizeof(long)> t1;
 323     sa<sizeof(sink_6_124578(ca))          == 2 * sizeof(long)> t2;
 324     sa<sizeof(sink_6_124578(va))          == 4 * sizeof(long)> t3;
 325     sa<sizeof(sink_6_124578(cva))         == 4 * sizeof(long)> t4;
 326     sa<sizeof(sink_6_124578(source()))    == 5 * sizeof(long)> t5;
 327     sa<sizeof(sink_6_124578(c_source()))  == 8 * sizeof(long)> t6;
 328     sa<sizeof(sink_6_124578(v_source()))  == 7 * sizeof(long)> t7;
 329     sa<sizeof(sink_6_124578(cv_source())) == 8 * sizeof(long)> t8;
 330     return 0;
 331 }
 332
 333 one   sink_6_124678(               A&);
 334 two   sink_6_124678(const          A&);
 335 four  sink_6_124678(const volatile A&);
 336 six   sink_6_124678(const          A&&);
 337 seven sink_6_124678(volatile       A&&);
 338 eight sink_6_124678(const volatile A&&);
 339
 340 int test6_124678()
 341 {
 342                    A a;
 343     const          A ca;
 344           volatile A va;
 345     const volatile A cva;
 346     sa<sizeof(sink_6_124678(a))           == 1 * sizeof(long)> t1;
 347     sa<sizeof(sink_6_124678(ca))          == 2 * sizeof(long)> t2;
 348     sa<sizeof(sink_6_124678(va))          == 4 * sizeof(long)> t3;
 349     sa<sizeof(sink_6_124678(cva))         == 4 * sizeof(long)> t4;
 350     sa<sizeof(sink_6_124678(c_source()))  == 6 * sizeof(long)> t6;
 351     sa<sizeof(sink_6_124678(v_source()))  == 7 * sizeof(long)> t7;
 352     sa<sizeof(sink_6_124678(cv_source())) == 8 * sizeof(long)> t8;
 353     return 0;
 354 }
 355
 356 one   sink_6_125678(               A&);
 357 two   sink_6_125678(const          A&);
 358 five  sink_6_125678(               A&&);
 359 six   sink_6_125678(const          A&&);
 360 seven sink_6_125678(volatile       A&&);
 361 eight sink_6_125678(const volatile A&&);
 362
 363 int test6_125678()
 364 {
 365                    A a;
 366     const          A ca;
 367           volatile A va;
 368     const volatile A cva;
 369     sa<sizeof(sink_6_125678(a))           == 1 * sizeof(long)> t1;
 370     sa<sizeof(sink_6_125678(ca))          == 2 * sizeof(long)> t2;
 371     sa<sizeof(sink_6_125678(source()))    == 5 * sizeof(long)> t5;
 372     sa<sizeof(sink_6_125678(c_source()))  == 6 * sizeof(long)> t6;
 373     sa<sizeof(sink_6_125678(v_source()))  == 7 * sizeof(long)> t7;
 374     sa<sizeof(sink_6_125678(cv_source())) == 8 * sizeof(long)> t8;
 375     return 0;
 376 }
 377
 378 one   sink_6_134567(               A&);
 379 three sink_6_134567(volatile       A&);
 380 four  sink_6_134567(const volatile A&);
 381 five  sink_6_134567(               A&&);
 382 six   sink_6_134567(const          A&&);
 383 seven sink_6_134567(volatile       A&&);
 384
 385 int test6_134567()
 386 {
 387                    A a;
 388     const          A ca;
 389           volatile A va;
 390     const volatile A cva;
 391     sa<sizeof(sink_6_134567(a))           == 1 * sizeof(long)> t1;
 392     sa<sizeof(sink_6_134567(ca))          == 4 * sizeof(long)> t2;
 393     sa<sizeof(sink_6_134567(va))          == 3 * sizeof(long)> t3;
 394     sa<sizeof(sink_6_134567(cva))         == 4 * sizeof(long)> t4;
 395     sa<sizeof(sink_6_134567(source()))    == 5 * sizeof(long)> t5;
 396     sa<sizeof(sink_6_134567(c_source()))  == 6 * sizeof(long)> t6;
 397     sa<sizeof(sink_6_134567(v_source()))  == 7 * sizeof(long)> t7;
 398     return 0;
 399 }
 400
 401 one   sink_6_134568(               A&);
 402 three sink_6_134568(volatile       A&);
 403 four  sink_6_134568(const volatile A&);
 404 five  sink_6_134568(               A&&);
 405 six   sink_6_134568(const          A&&);
 406 eight sink_6_134568(const volatile A&&);
 407
 408 int test6_134568()
 409 {
 410                    A a;
 411     const          A ca;
 412           volatile A va;
 413     const volatile A cva;
 414     sa<sizeof(sink_6_134568(a))           == 1 * sizeof(long)> t1;
 415     sa<sizeof(sink_6_134568(ca))          == 4 * sizeof(long)> t2;
 416     sa<sizeof(sink_6_134568(va))          == 3 * sizeof(long)> t3;
 417     sa<sizeof(sink_6_134568(cva))         == 4 * sizeof(long)> t4;
 418     sa<sizeof(sink_6_134568(source()))    == 5 * sizeof(long)> t5;
 419     sa<sizeof(sink_6_134568(c_source()))  == 6 * sizeof(long)> t6;
 420     sa<sizeof(sink_6_134568(v_source()))  == 8 * sizeof(long)> t7;
 421     sa<sizeof(sink_6_134568(cv_source())) == 8 * sizeof(long)> t8;
 422     return 0;
 423 }
 424
 425 one   sink_6_134578(               A&);
 426 three sink_6_134578(volatile       A&);
 427 four  sink_6_134578(const volatile A&);
 428 five  sink_6_134578(               A&&);
 429 seven sink_6_134578(volatile       A&&);
 430 eight sink_6_134578(const volatile A&&);
 431
 432 int test6_134578()
 433 {
 434                    A a;
 435     const          A ca;
 436           volatile A va;
 437     const volatile A cva;
 438     sa<sizeof(sink_6_134578(a))           == 1 * sizeof(long)> t1;
 439     sa<sizeof(sink_6_134578(ca))          == 4 * sizeof(long)> t2;
 440     sa<sizeof(sink_6_134578(va))          == 3 * sizeof(long)> t3;
 441     sa<sizeof(sink_6_134578(cva))         == 4 * sizeof(long)> t4;
 442     sa<sizeof(sink_6_134578(source()))    == 5 * sizeof(long)> t5;
 443     sa<sizeof(sink_6_134578(c_source()))  == 8 * sizeof(long)> t6;
 444     sa<sizeof(sink_6_134578(v_source()))  == 7 * sizeof(long)> t7;
 445     sa<sizeof(sink_6_134578(cv_source())) == 8 * sizeof(long)> t8;
 446     return 0;
 447 }
 448
 449 one   sink_6_134678(               A&);
 450 three sink_6_134678(volatile       A&);
 451 four  sink_6_134678(const volatile A&);
 452 six   sink_6_134678(const          A&&);
 453 seven sink_6_134678(volatile       A&&);
 454 eight sink_6_134678(const volatile A&&);
 455
 456 int test6_134678()
 457 {
 458                    A a;
 459     const          A ca;
 460           volatile A va;
 461     const volatile A cva;
 462     sa<sizeof(sink_6_134678(a))           == 1 * sizeof(long)> t1;
 463     sa<sizeof(sink_6_134678(ca))          == 4 * sizeof(long)> t2;
 464     sa<sizeof(sink_6_134678(va))          == 3 * sizeof(long)> t3;
 465     sa<sizeof(sink_6_134678(cva))         == 4 * sizeof(long)> t4;
 466     sa<sizeof(sink_6_134678(c_source()))  == 6 * sizeof(long)> t6;
 467     sa<sizeof(sink_6_134678(v_source()))  == 7 * sizeof(long)> t7;
 468     sa<sizeof(sink_6_134678(cv_source())) == 8 * sizeof(long)> t8;
 469     return 0;
 470 }
 471
 472 one   sink_6_135678(               A&);
 473 three sink_6_135678(volatile       A&);
 474 five  sink_6_135678(               A&&);
 475 six   sink_6_135678(const          A&&);
 476 seven sink_6_135678(volatile       A&&);
 477 eight sink_6_135678(const volatile A&&);
 478
 479 int test6_135678()
 480 {
 481                    A a;
 482     const          A ca;
 483           volatile A va;
 484     const volatile A cva;
 485     sa<sizeof(sink_6_135678(a))           == 1 * sizeof(long)> t1;
 486     sa<sizeof(sink_6_135678(va))          == 3 * sizeof(long)> t3;
 487     sa<sizeof(sink_6_135678(source()))    == 5 * sizeof(long)> t5;
 488     sa<sizeof(sink_6_135678(c_source()))  == 6 * sizeof(long)> t6;
 489     sa<sizeof(sink_6_135678(v_source()))  == 7 * sizeof(long)> t7;
 490     sa<sizeof(sink_6_135678(cv_source())) == 8 * sizeof(long)> t8;
 491     return 0;
 492 }
 493
 494 one   sink_6_145678(               A&);
 495 four  sink_6_145678(const volatile A&);
 496 five  sink_6_145678(               A&&);
 497 six   sink_6_145678(const          A&&);
 498 seven sink_6_145678(volatile       A&&);
 499 eight sink_6_145678(const volatile A&&);
 500
 501 int test6_145678()
 502 {
 503                    A a;
 504     const          A ca;
 505           volatile A va;
 506     const volatile A cva;
 507     sa<sizeof(sink_6_145678(a))           == 1 * sizeof(long)> t1;
 508     sa<sizeof(sink_6_145678(ca))          == 4 * sizeof(long)> t2;
 509     sa<sizeof(sink_6_145678(va))          == 4 * sizeof(long)> t3;
 510     sa<sizeof(sink_6_145678(cva))         == 4 * sizeof(long)> t4;
 511     sa<sizeof(sink_6_145678(source()))    == 5 * sizeof(long)> t5;
 512     sa<sizeof(sink_6_145678(c_source()))  == 6 * sizeof(long)> t6;
 513     sa<sizeof(sink_6_145678(v_source()))  == 7 * sizeof(long)> t7;
 514     sa<sizeof(sink_6_145678(cv_source())) == 8 * sizeof(long)> t8;
 515     return 0;
 516 }
 517
 518 two   sink_6_234567(const          A&);
 519 three sink_6_234567(volatile       A&);
 520 four  sink_6_234567(const volatile A&);
 521 five  sink_6_234567(               A&&);
 522 six   sink_6_234567(const          A&&);
 523 seven sink_6_234567(volatile       A&&);
 524
 525 int test6_234567()
 526 {
 527                    A a;
 528     const          A ca;
 529           volatile A va;
 530     const volatile A cva;
 531     sa<sizeof(sink_6_234567(ca))          == 2 * sizeof(long)> t2;
 532     sa<sizeof(sink_6_234567(va))          == 3 * sizeof(long)> t3;
 533     sa<sizeof(sink_6_234567(cva))         == 4 * sizeof(long)> t4;
 534     sa<sizeof(sink_6_234567(source()))    == 5 * sizeof(long)> t5;
 535     sa<sizeof(sink_6_234567(c_source()))  == 6 * sizeof(long)> t6;
 536     sa<sizeof(sink_6_234567(v_source()))  == 7 * sizeof(long)> t7;
 537     return 0;
 538 }
 539
 540 two   sink_6_234568(const          A&);
 541 three sink_6_234568(volatile       A&);
 542 four  sink_6_234568(const volatile A&);
 543 five  sink_6_234568(               A&&);
 544 six   sink_6_234568(const          A&&);
 545 eight sink_6_234568(const volatile A&&);
 546
 547 int test6_234568()
 548 {
 549                    A a;
 550     const          A ca;
 551           volatile A va;
 552     const volatile A cva;
 553     sa<sizeof(sink_6_234568(ca))          == 2 * sizeof(long)> t2;
 554     sa<sizeof(sink_6_234568(va))          == 3 * sizeof(long)> t3;
 555     sa<sizeof(sink_6_234568(cva))         == 4 * sizeof(long)> t4;
 556     sa<sizeof(sink_6_234568(source()))    == 5 * sizeof(long)> t5;
 557     sa<sizeof(sink_6_234568(c_source()))  == 6 * sizeof(long)> t6;
 558     sa<sizeof(sink_6_234568(v_source()))  == 8 * sizeof(long)> t7;
 559     sa<sizeof(sink_6_234568(cv_source())) == 8 * sizeof(long)> t8;
 560     return 0;
 561 }
 562
 563 two   sink_6_234578(const          A&);
 564 three sink_6_234578(volatile       A&);
 565 four  sink_6_234578(const volatile A&);
 566 five  sink_6_234578(               A&&);
 567 seven sink_6_234578(volatile       A&&);
 568 eight sink_6_234578(const volatile A&&);
 569
 570 int test6_234578()
 571 {
 572                    A a;
 573     const          A ca;
 574           volatile A va;
 575     const volatile A cva;
 576     sa<sizeof(sink_6_234578(ca))          == 2 * sizeof(long)> t2;
 577     sa<sizeof(sink_6_234578(va))          == 3 * sizeof(long)> t3;
 578     sa<sizeof(sink_6_234578(cva))         == 4 * sizeof(long)> t4;
 579     sa<sizeof(sink_6_234578(source()))    == 5 * sizeof(long)> t5;
 580     sa<sizeof(sink_6_234578(c_source()))  == 8 * sizeof(long)> t6;
 581     sa<sizeof(sink_6_234578(v_source()))  == 7 * sizeof(long)> t7;
 582     sa<sizeof(sink_6_234578(cv_source())) == 8 * sizeof(long)> t8;
 583     return 0;
 584 }
 585
 586 two   sink_6_234678(const          A&);
 587 three sink_6_234678(volatile       A&);
 588 four  sink_6_234678(const volatile A&);
 589 six   sink_6_234678(const          A&&);
 590 seven sink_6_234678(volatile       A&&);
 591 eight sink_6_234678(const volatile A&&);
 592
 593 int test6_234678()
 594 {
 595                    A a;
 596     const          A ca;
 597           volatile A va;
 598     const volatile A cva;
 599     sa<sizeof(sink_6_234678(ca))          == 2 * sizeof(long)> t2;
 600     sa<sizeof(sink_6_234678(va))          == 3 * sizeof(long)> t3;
 601     sa<sizeof(sink_6_234678(cva))         == 4 * sizeof(long)> t4;
 602     sa<sizeof(sink_6_234678(c_source()))  == 6 * sizeof(long)> t6;
 603     sa<sizeof(sink_6_234678(v_source()))  == 7 * sizeof(long)> t7;
 604     sa<sizeof(sink_6_234678(cv_source())) == 8 * sizeof(long)> t8;
 605     return 0;
 606 }
 607
 608 two   sink_6_235678(const          A&);
 609 three sink_6_235678(volatile       A&);
 610 five  sink_6_235678(               A&&);
 611 six   sink_6_235678(const          A&&);
 612 seven sink_6_235678(volatile       A&&);
 613 eight sink_6_235678(const volatile A&&);
 614
 615 int test6_235678()
 616 {
 617                    A a;
 618     const          A ca;
 619           volatile A va;
 620     const volatile A cva;
 621     sa<sizeof(sink_6_235678(ca))          == 2 * sizeof(long)> t2;
 622     sa<sizeof(sink_6_235678(va))          == 3 * sizeof(long)> t3;
 623     sa<sizeof(sink_6_235678(source()))    == 5 * sizeof(long)> t5;
 624     sa<sizeof(sink_6_235678(c_source()))  == 6 * sizeof(long)> t6;
 625     sa<sizeof(sink_6_235678(v_source()))  == 7 * sizeof(long)> t7;
 626     sa<sizeof(sink_6_235678(cv_source())) == 8 * sizeof(long)> t8;
 627     return 0;
 628 }
 629
 630 two   sink_6_245678(const          A&);
 631 four  sink_6_245678(const volatile A&);
 632 five  sink_6_245678(               A&&);
 633 six   sink_6_245678(const          A&&);
 634 seven sink_6_245678(volatile       A&&);
 635 eight sink_6_245678(const volatile A&&);
 636
 637 int test6_245678()
 638 {
 639                    A a;
 640     const          A ca;
 641           volatile A va;
 642     const volatile A cva;
 643     sa<sizeof(sink_6_245678(a))           == 2 * sizeof(long)> t1;
 644     sa<sizeof(sink_6_245678(ca))          == 2 * sizeof(long)> t2;
 645     sa<sizeof(sink_6_245678(va))          == 4 * sizeof(long)> t3;
 646     sa<sizeof(sink_6_245678(cva))         == 4 * sizeof(long)> t4;
 647     sa<sizeof(sink_6_245678(source()))    == 5 * sizeof(long)> t5;
 648     sa<sizeof(sink_6_245678(c_source()))  == 6 * sizeof(long)> t6;
 649     sa<sizeof(sink_6_245678(v_source()))  == 7 * sizeof(long)> t7;
 650     sa<sizeof(sink_6_245678(cv_source())) == 8 * sizeof(long)> t8;
 651     return 0;
 652 }
 653
 654 three sink_6_345678(volatile       A&);
 655 four  sink_6_345678(const volatile A&);
 656 five  sink_6_345678(               A&&);
 657 six   sink_6_345678(const          A&&);
 658 seven sink_6_345678(volatile       A&&);
 659 eight sink_6_345678(const volatile A&&);
 660
 661 int test6_345678()
 662 {
 663                    A a;
 664     const          A ca;
 665           volatile A va;
 666     const volatile A cva;
 667     sa<sizeof(sink_6_345678(a))           == 3 * sizeof(long)> t1;
 668     sa<sizeof(sink_6_345678(ca))          == 4 * sizeof(long)> t2;
 669     sa<sizeof(sink_6_345678(va))          == 3 * sizeof(long)> t3;
 670     sa<sizeof(sink_6_345678(cva))         == 4 * sizeof(long)> t4;
 671     sa<sizeof(sink_6_345678(source()))    == 5 * sizeof(long)> t5;
 672     sa<sizeof(sink_6_345678(c_source()))  == 6 * sizeof(long)> t6;
 673     sa<sizeof(sink_6_345678(v_source()))  == 7 * sizeof(long)> t7;
 674     sa<sizeof(sink_6_345678(cv_source())) == 8 * sizeof(long)> t8;
 675     return 0;
 676 }
 677
 678 int main()
 679 {
 680     return test6_123456() + test6_123457() + test6_123458() + test6_123467() +
 681            test6_123468() + test6_123478() + test6_123567() + test6_123568() +
 682            test6_123578() + test6_123678() + test6_124567() + test6_124568() +
 683            test6_124578() + test6_124678() + test6_125678() + test6_134567() +
 684            test6_134568() + test6_134578() + test6_134678() + test6_135678() +
 685            test6_145678() + test6_234567() + test6_234568() + test6_234578() +
 686            test6_234678() + test6_235678() + test6_245678() + test6_345678();
 687 }