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