URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [rv5p.C] - Blame information for rev 378

Details | Compare with Previous | View Log


// I, Howard Hinnant, hereby place this code in the public domain.
 
// Test overload resolution among reference types
 
// { dg-do compile }
// { dg-options "-std=c++0x" }
 
template  struct sa;
template <> struct sa {};
 
struct one   {long x[1];};
struct two   {long x[2];};
struct three {long x[3];};
struct four  {long x[4];};
struct five  {long x[5];};
struct six   {long x[6];};
struct seven {long x[7];};
struct eight {long x[8];};
 
struct A
{
    A();
    A(const volatile A&&);
};
 
               A    source();
const          A  c_source();
      volatile A  v_source();
const volatile A cv_source();
 
// 5 at a time
 
one   sink_5_12345(               A&);
two   sink_5_12345(const          A&);
three sink_5_12345(volatile       A&);
four  sink_5_12345(const volatile A&);
five  sink_5_12345(               A&&);
 
int test5_12345()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_5_12346(               A&);
two   sink_5_12346(const          A&);
three sink_5_12346(volatile       A&);
four  sink_5_12346(const volatile A&);
six   sink_5_12346(const          A&&);
 
int test5_12346()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_5_12347(               A&);
two   sink_5_12347(const          A&);
three sink_5_12347(volatile       A&);
four  sink_5_12347(const volatile A&);
seven sink_5_12347(volatile       A&&);
 
int test5_12347()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12348(               A&);
two   sink_5_12348(const          A&);
three sink_5_12348(volatile       A&);
four  sink_5_12348(const volatile A&);
eight sink_5_12348(const volatile A&&);
 
int test5_12348()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12356(               A&);
two   sink_5_12356(const          A&);
three sink_5_12356(volatile       A&);
five  sink_5_12356(               A&&);
six   sink_5_12356(const          A&&);
 
int test5_12356()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_5_12357(               A&);
two   sink_5_12357(const          A&);
three sink_5_12357(volatile       A&);
five  sink_5_12357(               A&&);
seven sink_5_12357(volatile       A&&);
 
int test5_12357()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12358(               A&);
two   sink_5_12358(const          A&);
three sink_5_12358(volatile       A&);
five  sink_5_12358(               A&&);
eight sink_5_12358(const volatile A&&);
 
int test5_12358()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12367(               A&);
two   sink_5_12367(const          A&);
three sink_5_12367(volatile       A&);
six   sink_5_12367(const          A&&);
seven sink_5_12367(volatile       A&&);
 
int test5_12367()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12368(               A&);
two   sink_5_12368(const          A&);
three sink_5_12368(volatile       A&);
six   sink_5_12368(const          A&&);
eight sink_5_12368(const volatile A&&);
 
int test5_12368()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12378(               A&);
two   sink_5_12378(const          A&);
three sink_5_12378(volatile       A&);
seven sink_5_12378(volatile       A&&);
eight sink_5_12378(const volatile A&&);
 
int test5_12378()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12456(               A&);
two   sink_5_12456(const          A&);
four  sink_5_12456(const volatile A&);
five  sink_5_12456(               A&&);
six   sink_5_12456(const          A&&);
 
int test5_12456()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_5_12457(               A&);
two   sink_5_12457(const          A&);
four  sink_5_12457(const volatile A&);
five  sink_5_12457(               A&&);
seven sink_5_12457(volatile       A&&);
 
int test5_12457()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12458(               A&);
two   sink_5_12458(const          A&);
four  sink_5_12458(const volatile A&);
five  sink_5_12458(               A&&);
eight sink_5_12458(const volatile A&&);
 
int test5_12458()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12467(               A&);
two   sink_5_12467(const          A&);
four  sink_5_12467(const volatile A&);
six   sink_5_12467(const          A&&);
seven sink_5_12467(volatile       A&&);
 
int test5_12467()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12468(               A&);
two   sink_5_12468(const          A&);
four  sink_5_12468(const volatile A&);
six   sink_5_12468(const          A&&);
eight sink_5_12468(const volatile A&&);
 
int test5_12468()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12478(               A&);
two   sink_5_12478(const          A&);
four  sink_5_12478(const volatile A&);
seven sink_5_12478(volatile       A&&);
eight sink_5_12478(const volatile A&&);
 
int test5_12478()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12567(               A&);
two   sink_5_12567(const          A&);
five  sink_5_12567(               A&&);
six   sink_5_12567(const          A&&);
seven sink_5_12567(volatile       A&&);
 
int test5_12567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_12568(               A&);
two   sink_5_12568(const          A&);
five  sink_5_12568(               A&&);
six   sink_5_12568(const          A&&);
eight sink_5_12568(const volatile A&&);
 
int test5_12568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12578(               A&);
two   sink_5_12578(const          A&);
five  sink_5_12578(               A&&);
seven sink_5_12578(volatile       A&&);
eight sink_5_12578(const volatile A&&);
 
int test5_12578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_12678(               A&);
two   sink_5_12678(const          A&);
six   sink_5_12678(const          A&&);
seven sink_5_12678(volatile       A&&);
eight sink_5_12678(const volatile A&&);
 
int test5_12678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13456(               A&);
three sink_5_13456(volatile       A&);
four  sink_5_13456(const volatile A&);
five  sink_5_13456(               A&&);
six   sink_5_13456(const          A&&);
 
int test5_13456()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_5_13457(               A&);
three sink_5_13457(volatile       A&);
four  sink_5_13457(const volatile A&);
five  sink_5_13457(               A&&);
seven sink_5_13457(volatile       A&&);
 
int test5_13457()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t7;
    return 0;
}
 
one   sink_5_13458(               A&);
three sink_5_13458(volatile       A&);
four  sink_5_13458(const volatile A&);
five  sink_5_13458(               A&&);
eight sink_5_13458(const volatile A&&);
 
int test5_13458()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13467(               A&);
three sink_5_13467(volatile       A&);
four  sink_5_13467(const volatile A&);
six   sink_5_13467(const          A&&);
seven sink_5_13467(volatile       A&&);
 
int test5_13467()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_13468(               A&);
three sink_5_13468(volatile       A&);
four  sink_5_13468(const volatile A&);
six   sink_5_13468(const          A&&);
eight sink_5_13468(const volatile A&&);
 
int test5_13468()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13478(               A&);
three sink_5_13478(volatile       A&);
four  sink_5_13478(const volatile A&);
seven sink_5_13478(volatile       A&&);
eight sink_5_13478(const volatile A&&);
 
int test5_13478()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13567(               A&);
three sink_5_13567(volatile       A&);
five  sink_5_13567(               A&&);
six   sink_5_13567(const          A&&);
seven sink_5_13567(volatile       A&&);
 
int test5_13567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_13568(               A&);
three sink_5_13568(volatile       A&);
five  sink_5_13568(               A&&);
six   sink_5_13568(const          A&&);
eight sink_5_13568(const volatile A&&);
 
int test5_13568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13578(               A&);
three sink_5_13578(volatile       A&);
five  sink_5_13578(               A&&);
seven sink_5_13578(volatile       A&&);
eight sink_5_13578(const volatile A&&);
 
int test5_13578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_13678(               A&);
three sink_5_13678(volatile       A&);
six   sink_5_13678(const          A&&);
seven sink_5_13678(volatile       A&&);
eight sink_5_13678(const volatile A&&);
 
int test5_13678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_14567(               A&);
four  sink_5_14567(const volatile A&);
five  sink_5_14567(               A&&);
six   sink_5_14567(const          A&&);
seven sink_5_14567(volatile       A&&);
 
int test5_14567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_5_14568(               A&);
four  sink_5_14568(const volatile A&);
five  sink_5_14568(               A&&);
six   sink_5_14568(const          A&&);
eight sink_5_14568(const volatile A&&);
 
int test5_14568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_14578(               A&);
four  sink_5_14578(const volatile A&);
five  sink_5_14578(               A&&);
seven sink_5_14578(volatile       A&&);
eight sink_5_14578(const volatile A&&);
 
int test5_14578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_14678(               A&);
four  sink_5_14678(const volatile A&);
six   sink_5_14678(const          A&&);
seven sink_5_14678(volatile       A&&);
eight sink_5_14678(const volatile A&&);
 
int test5_14678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
one   sink_5_15678(               A&);
five  sink_5_15678(               A&&);
six   sink_5_15678(const          A&&);
seven sink_5_15678(volatile       A&&);
eight sink_5_15678(const volatile A&&);
 
int test5_15678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23456(const          A&);
three sink_5_23456(volatile       A&);
four  sink_5_23456(const volatile A&);
five  sink_5_23456(               A&&);
six   sink_5_23456(const          A&&);
 
int test5_23456()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_5_23457(const          A&);
three sink_5_23457(volatile       A&);
four  sink_5_23457(const volatile A&);
five  sink_5_23457(               A&&);
seven sink_5_23457(volatile       A&&);
 
int test5_23457()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_5_23458(const          A&);
three sink_5_23458(volatile       A&);
four  sink_5_23458(const volatile A&);
five  sink_5_23458(               A&&);
eight sink_5_23458(const volatile A&&);
 
int test5_23458()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23467(const          A&);
three sink_5_23467(volatile       A&);
four  sink_5_23467(const volatile A&);
six   sink_5_23467(const          A&&);
seven sink_5_23467(volatile       A&&);
 
int test5_23467()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_5_23468(const          A&);
three sink_5_23468(volatile       A&);
four  sink_5_23468(const volatile A&);
six   sink_5_23468(const          A&&);
eight sink_5_23468(const volatile A&&);
 
int test5_23468()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23478(const          A&);
three sink_5_23478(volatile       A&);
four  sink_5_23478(const volatile A&);
seven sink_5_23478(volatile       A&&);
eight sink_5_23478(const volatile A&&);
 
int test5_23478()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23567(const          A&);
three sink_5_23567(volatile       A&);
five  sink_5_23567(               A&&);
six   sink_5_23567(const          A&&);
seven sink_5_23567(volatile       A&&);
 
int test5_23567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_5_23568(const          A&);
three sink_5_23568(volatile       A&);
five  sink_5_23568(               A&&);
six   sink_5_23568(const          A&&);
eight sink_5_23568(const volatile A&&);
 
int test5_23568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23578(const          A&);
three sink_5_23578(volatile       A&);
five  sink_5_23578(               A&&);
seven sink_5_23578(volatile       A&&);
eight sink_5_23578(const volatile A&&);
 
int test5_23578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_23678(const          A&);
three sink_5_23678(volatile       A&);
six   sink_5_23678(const          A&&);
seven sink_5_23678(volatile       A&&);
eight sink_5_23678(const volatile A&&);
 
int test5_23678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_24567(const          A&);
four  sink_5_24567(const volatile A&);
five  sink_5_24567(               A&&);
six   sink_5_24567(const          A&&);
seven sink_5_24567(volatile       A&&);
 
int test5_24567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_5_24568(const          A&);
four  sink_5_24568(const volatile A&);
five  sink_5_24568(               A&&);
six   sink_5_24568(const          A&&);
eight sink_5_24568(const volatile A&&);
 
int test5_24568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_24578(const          A&);
four  sink_5_24578(const volatile A&);
five  sink_5_24578(               A&&);
seven sink_5_24578(volatile       A&&);
eight sink_5_24578(const volatile A&&);
 
int test5_24578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_24678(const          A&);
four  sink_5_24678(const volatile A&);
six   sink_5_24678(const          A&&);
seven sink_5_24678(volatile       A&&);
eight sink_5_24678(const volatile A&&);
 
int test5_24678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_5_25678(const          A&);
five  sink_5_25678(               A&&);
six   sink_5_25678(const          A&&);
seven sink_5_25678(volatile       A&&);
eight sink_5_25678(const volatile A&&);
 
int test5_25678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_5_34567(volatile       A&);
four  sink_5_34567(const volatile A&);
five  sink_5_34567(               A&&);
six   sink_5_34567(const          A&&);
seven sink_5_34567(volatile       A&&);
 
int test5_34567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
three sink_5_34568(volatile       A&);
four  sink_5_34568(const volatile A&);
five  sink_5_34568(               A&&);
six   sink_5_34568(const          A&&);
eight sink_5_34568(const volatile A&&);
 
int test5_34568()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_5_34578(volatile       A&);
four  sink_5_34578(const volatile A&);
five  sink_5_34578(               A&&);
seven sink_5_34578(volatile       A&&);
eight sink_5_34578(const volatile A&&);
 
int test5_34578()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_5_34678(volatile       A&);
four  sink_5_34678(const volatile A&);
six   sink_5_34678(const          A&&);
seven sink_5_34678(volatile       A&&);
eight sink_5_34678(const volatile A&&);
 
int test5_34678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
three sink_5_35678(volatile       A&);
five  sink_5_35678(               A&&);
six   sink_5_35678(const          A&&);
seven sink_5_35678(volatile       A&&);
eight sink_5_35678(const volatile A&&);
 
int test5_35678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
four  sink_5_45678(const volatile A&);
five  sink_5_45678(               A&&);
six   sink_5_45678(const          A&&);
seven sink_5_45678(volatile       A&&);
eight sink_5_45678(const volatile A&&);
 
int test5_45678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
int main()
{
    return test5_12345() + test5_12346() + test5_12347() + test5_12348() +
           test5_12356() + test5_12357() + test5_12358() + test5_12367() +
           test5_12368() + test5_12378() + test5_12456() + test5_12457() +
           test5_12458() + test5_12467() + test5_12468() + test5_12478() +
           test5_12567() + test5_12568() + test5_12578() + test5_12678() +
           test5_13456() + test5_13457() + test5_13458() + test5_13467() +
           test5_13468() + test5_13478() + test5_13567() + test5_13568() +
           test5_13578() + test5_13678() + test5_14567() + test5_14568() +
           test5_14578() + test5_14678() + test5_15678() + test5_23456() +
           test5_23457() + test5_23458() + test5_23467() + test5_23468() +
           test5_23478() + test5_23567() + test5_23568() + test5_23578() +
           test5_23678() + test5_24567() + test5_24568() + test5_24578() +
           test5_24678() + test5_25678() + test5_34567() + test5_34568() +
           test5_34578() + test5_34678() + test5_35678() + test5_45678();
}

Line No.	Rev	Author	Line
1	301	jeremybenn	`// 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 struct sa;`
9			`template <> struct sa {};`
10
11	378	julius	`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	301	jeremybenn
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			`// 5 at a time`
32
33			`one sink_5_12345( A&);`
34			`two sink_5_12345(const A&);`
35			`three sink_5_12345(volatile A&);`
36			`four sink_5_12345(const volatile A&);`
37			`five sink_5_12345( A&&);`
38
39			`int test5_12345()`
40			`{`
41			`A a;`
42			`const A ca = a;`
43			`volatile A va;`
44			`const volatile A cva = a;`
45	378	julius	`sa t1;`
46			`sa t2;`
47			`sa t3;`
48			`sa t4;`
49			`sa t5;`
50			`sa t6;`
51	301	jeremybenn	`return 0;`
52			`}`
53
54			`one sink_5_12346( A&);`
55			`two sink_5_12346(const A&);`
56			`three sink_5_12346(volatile A&);`
57			`four sink_5_12346(const volatile A&);`
58			`six sink_5_12346(const A&&);`
59
60			`int test5_12346()`
61			`{`
62			`A a;`
63			`const A ca = a;`
64			`volatile A va;`
65			`const volatile A cva = a;`
66	378	julius	`sa t1;`
67			`sa t2;`
68			`sa t3;`
69			`sa t4;`
70			`sa t5;`
71			`sa t6;`
72	301	jeremybenn	`return 0;`
73			`}`
74
75			`one sink_5_12347( A&);`
76			`two sink_5_12347(const A&);`
77			`three sink_5_12347(volatile A&);`
78			`four sink_5_12347(const volatile A&);`
79			`seven sink_5_12347(volatile A&&);`
80
81			`int test5_12347()`
82			`{`
83			`A a;`
84			`const A ca = a;`
85			`volatile A va;`
86			`const volatile A cva = a;`
87	378	julius	`sa t1;`
88			`sa t2;`
89			`sa t3;`
90			`sa t4;`
91			`sa t5;`
92			`sa t6;`
93			`sa t7;`
94	301	jeremybenn	`return 0;`
95			`}`
96
97			`one sink_5_12348( A&);`
98			`two sink_5_12348(const A&);`
99			`three sink_5_12348(volatile A&);`
100			`four sink_5_12348(const volatile A&);`
101			`eight sink_5_12348(const volatile A&&);`
102
103			`int test5_12348()`
104			`{`
105			`A a;`
106			`const A ca = a;`
107			`volatile A va;`
108			`const volatile A cva = a;`
109	378	julius	`sa t1;`
110			`sa t2;`
111			`sa t3;`
112			`sa t4;`
113			`sa t5;`
114			`sa t6;`
115			`sa t7;`
116			`sa t8;`
117	301	jeremybenn	`return 0;`
118			`}`
119
120			`one sink_5_12356( A&);`
121			`two sink_5_12356(const A&);`
122			`three sink_5_12356(volatile A&);`
123			`five sink_5_12356( A&&);`
124			`six sink_5_12356(const A&&);`
125
126			`int test5_12356()`
127			`{`
128			`A a;`
129			`const A ca = a;`
130			`volatile A va;`
131			`const volatile A cva = a;`
132	378	julius	`sa t1;`
133			`sa t2;`
134			`sa t3;`
135			`sa t5;`
136			`sa t6;`
137	301	jeremybenn	`return 0;`
138			`}`
139
140			`one sink_5_12357( A&);`
141			`two sink_5_12357(const A&);`
142			`three sink_5_12357(volatile A&);`
143			`five sink_5_12357( A&&);`
144			`seven sink_5_12357(volatile A&&);`
145
146			`int test5_12357()`
147			`{`
148			`A a;`
149			`const A ca = a;`
150			`volatile A va;`
151			`const volatile A cva = a;`
152	378	julius	`sa t1;`
153			`sa t2;`
154			`sa t3;`
155			`sa t5;`
156			`sa t6;`
157			`sa t7;`
158	301	jeremybenn	`return 0;`
159			`}`
160
161			`one sink_5_12358( A&);`
162			`two sink_5_12358(const A&);`
163			`three sink_5_12358(volatile A&);`
164			`five sink_5_12358( A&&);`
165			`eight sink_5_12358(const volatile A&&);`
166
167			`int test5_12358()`
168			`{`
169			`A a;`
170			`const A ca = a;`
171			`volatile A va;`
172			`const volatile A cva = a;`
173	378	julius	`sa t1;`
174			`sa t2;`
175			`sa t3;`
176			`sa t5;`
177			`sa t6;`
178			`sa t7;`
179			`sa t8;`
180	301	jeremybenn	`return 0;`
181			`}`
182
183			`one sink_5_12367( A&);`
184			`two sink_5_12367(const A&);`
185			`three sink_5_12367(volatile A&);`
186			`six sink_5_12367(const A&&);`
187			`seven sink_5_12367(volatile A&&);`
188
189			`int test5_12367()`
190			`{`
191			`A a;`
192			`const A ca = a;`
193			`volatile A va;`
194			`const volatile A cva = a;`
195	378	julius	`sa t1;`
196			`sa t2;`
197			`sa t3;`
198			`sa t6;`
199			`sa t7;`
200	301	jeremybenn	`return 0;`
201			`}`
202
203			`one sink_5_12368( A&);`
204			`two sink_5_12368(const A&);`
205			`three sink_5_12368(volatile A&);`
206			`six sink_5_12368(const A&&);`
207			`eight sink_5_12368(const volatile A&&);`
208
209			`int test5_12368()`
210			`{`
211			`A a;`
212			`const A ca = a;`
213			`volatile A va;`
214			`const volatile A cva = a;`
215	378	julius	`sa t1;`
216			`sa t2;`
217			`sa t3;`
218			`sa t5;`
219			`sa t6;`
220			`sa t7;`
221			`sa t8;`
222	301	jeremybenn	`return 0;`
223			`}`
224
225			`one sink_5_12378( A&);`
226			`two sink_5_12378(const A&);`
227			`three sink_5_12378(volatile A&);`
228			`seven sink_5_12378(volatile A&&);`
229			`eight sink_5_12378(const volatile A&&);`
230
231			`int test5_12378()`
232			`{`
233			`A a;`
234			`const A ca = a;`
235			`volatile A va;`
236			`const volatile A cva = a;`
237	378	julius	`sa t1;`
238			`sa t2;`
239			`sa t3;`
240			`sa t5;`
241			`sa t6;`
242			`sa t7;`
243			`sa t8;`
244	301	jeremybenn	`return 0;`
245			`}`
246
247			`one sink_5_12456( A&);`
248			`two sink_5_12456(const A&);`
249			`four sink_5_12456(const volatile A&);`
250			`five sink_5_12456( A&&);`
251			`six sink_5_12456(const A&&);`
252
253			`int test5_12456()`
254			`{`
255			`A a;`
256			`const A ca = a;`
257			`volatile A va;`
258			`const volatile A cva = a;`
259	378	julius	`sa t1;`
260			`sa t2;`
261			`sa t3;`
262			`sa t4;`
263			`sa t5;`
264			`sa t6;`
265	301	jeremybenn	`return 0;`
266			`}`
267
268			`one sink_5_12457( A&);`
269			`two sink_5_12457(const A&);`
270			`four sink_5_12457(const volatile A&);`
271			`five sink_5_12457( A&&);`
272			`seven sink_5_12457(volatile A&&);`
273
274			`int test5_12457()`
275			`{`
276			`A a;`
277			`const A ca = a;`
278			`volatile A va;`
279			`const volatile A cva = a;`
280	378	julius	`sa t1;`
281			`sa t2;`
282			`sa t3;`
283			`sa t4;`
284			`sa t5;`
285			`sa t6;`
286			`sa t7;`
287	301	jeremybenn	`return 0;`
288			`}`
289
290			`one sink_5_12458( A&);`
291			`two sink_5_12458(const A&);`
292			`four sink_5_12458(const volatile A&);`
293			`five sink_5_12458( A&&);`
294			`eight sink_5_12458(const volatile A&&);`
295
296			`int test5_12458()`
297			`{`
298			`A a;`
299			`const A ca = a;`
300			`volatile A va;`
301			`const volatile A cva = a;`
302	378	julius	`sa t1;`
303			`sa t2;`
304			`sa t3;`
305			`sa t4;`
306			`sa t5;`
307			`sa t6;`
308			`sa t7;`
309			`sa t8;`
310	301	jeremybenn	`return 0;`
311			`}`
312
313			`one sink_5_12467( A&);`
314			`two sink_5_12467(const A&);`
315			`four sink_5_12467(const volatile A&);`
316			`six sink_5_12467(const A&&);`
317			`seven sink_5_12467(volatile A&&);`
318
319			`int test5_12467()`
320			`{`
321			`A a;`
322			`const A ca = a;`
323			`volatile A va;`
324			`const volatile A cva = a;`
325	378	julius	`sa t1;`
326			`sa t2;`
327			`sa t3;`
328			`sa t4;`
329			`sa t6;`
330			`sa t7;`
331	301	jeremybenn	`return 0;`
332			`}`
333
334			`one sink_5_12468( A&);`
335			`two sink_5_12468(const A&);`
336			`four sink_5_12468(const volatile A&);`
337			`six sink_5_12468(const A&&);`
338			`eight sink_5_12468(const volatile A&&);`
339
340			`int test5_12468()`
341			`{`
342			`A a;`
343			`const A ca = a;`
344			`volatile A va;`
345			`const volatile A cva = a;`
346	378	julius	`sa t1;`
347			`sa t2;`
348			`sa t3;`
349			`sa t4;`
350			`sa t5;`
351			`sa t6;`
352			`sa t7;`
353			`sa t8;`
354	301	jeremybenn	`return 0;`
355			`}`
356
357			`one sink_5_12478( A&);`
358			`two sink_5_12478(const A&);`
359			`four sink_5_12478(const volatile A&);`
360			`seven sink_5_12478(volatile A&&);`
361			`eight sink_5_12478(const volatile A&&);`
362
363			`int test5_12478()`
364			`{`
365			`A a;`
366			`const A ca = a;`
367			`volatile A va;`
368			`const volatile A cva = a;`
369	378	julius	`sa t1;`
370			`sa t2;`
371			`sa t3;`
372			`sa t4;`
373			`sa t5;`
374			`sa t6;`
375			`sa t7;`
376			`sa t8;`
377	301	jeremybenn	`return 0;`
378			`}`
379
380			`one sink_5_12567( A&);`
381			`two sink_5_12567(const A&);`
382			`five sink_5_12567( A&&);`
383			`six sink_5_12567(const A&&);`
384			`seven sink_5_12567(volatile A&&);`
385
386			`int test5_12567()`
387			`{`
388			`A a;`
389			`const A ca = a;`
390			`volatile A va;`
391			`const volatile A cva = a;`
392	378	julius	`sa t1;`
393			`sa t2;`
394			`sa t5;`
395			`sa t6;`
396			`sa t7;`
397	301	jeremybenn	`return 0;`
398			`}`
399
400			`one sink_5_12568( A&);`
401			`two sink_5_12568(const A&);`
402			`five sink_5_12568( A&&);`
403			`six sink_5_12568(const A&&);`
404			`eight sink_5_12568(const volatile A&&);`
405
406			`int test5_12568()`
407			`{`
408			`A a;`
409			`const A ca = a;`
410			`volatile A va;`
411			`const volatile A cva = a;`
412	378	julius	`sa t1;`
413			`sa t2;`
414			`sa t5;`
415			`sa t6;`
416			`sa t7;`
417			`sa t8;`
418	301	jeremybenn	`return 0;`
419			`}`
420
421			`one sink_5_12578( A&);`
422			`two sink_5_12578(const A&);`
423			`five sink_5_12578( A&&);`
424			`seven sink_5_12578(volatile A&&);`
425			`eight sink_5_12578(const volatile A&&);`
426
427			`int test5_12578()`
428			`{`
429			`A a;`
430			`const A ca = a;`
431			`volatile A va;`
432			`const volatile A cva = a;`
433	378	julius	`sa t1;`
434			`sa t2;`
435			`sa t5;`
436			`sa t6;`
437			`sa t7;`
438			`sa t8;`
439	301	jeremybenn	`return 0;`
440			`}`
441
442			`one sink_5_12678( A&);`
443			`two sink_5_12678(const A&);`
444			`six sink_5_12678(const A&&);`
445			`seven sink_5_12678(volatile A&&);`
446			`eight sink_5_12678(const volatile A&&);`
447
448			`int test5_12678()`
449			`{`
450			`A a;`
451			`const A ca = a;`
452			`volatile A va;`
453			`const volatile A cva = a;`
454	378	julius	`sa t1;`
455			`sa t2;`
456			`sa t6;`
457			`sa t7;`
458			`sa t8;`
459	301	jeremybenn	`return 0;`
460			`}`
461
462			`one sink_5_13456( A&);`
463			`three sink_5_13456(volatile A&);`
464			`four sink_5_13456(const volatile A&);`
465			`five sink_5_13456( A&&);`
466			`six sink_5_13456(const A&&);`
467
468			`int test5_13456()`
469			`{`
470			`A a;`
471			`const A ca = a;`
472			`volatile A va;`
473			`const volatile A cva = a;`
474	378	julius	`sa t1;`
475			`sa t2;`
476			`sa t3;`
477			`sa t4;`
478			`sa t5;`
479			`sa t6;`
480	301	jeremybenn	`return 0;`
481			`}`
482
483			`one sink_5_13457( A&);`
484			`three sink_5_13457(volatile A&);`
485			`four sink_5_13457(const volatile A&);`
486			`five sink_5_13457( A&&);`
487			`seven sink_5_13457(volatile A&&);`
488
489			`int test5_13457()`
490			`{`
491			`A a;`
492			`const A ca = a;`
493			`volatile A va;`
494			`const volatile A cva = a;`
495	378	julius	`sa t1;`
496			`sa t2;`
497			`sa t3;`
498			`sa t4;`
499			`sa t5;`
500			`sa t7;`

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [rv5p.C] - Blame information for rev 378