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/] [rv4p.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();
 
// 4 at a time
 
one   sink_4_1234(               A&);
two   sink_4_1234(const          A&);
three sink_4_1234(volatile       A&);
four  sink_4_1234(const volatile A&);
 
int test4_1234()
{
                   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_4_1235(               A&);
two   sink_4_1235(const          A&);
three sink_4_1235(volatile       A&);
five  sink_4_1235(               A&&);
 
int test4_1235()
{
                   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_4_1236(               A&);
two   sink_4_1236(const          A&);
three sink_4_1236(volatile       A&);
six   sink_4_1236(const          A&&);
 
int test4_1236()
{
                   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_4_1237(               A&);
two   sink_4_1237(const          A&);
three sink_4_1237(volatile       A&);
seven sink_4_1237(volatile       A&&);
 
int test4_1237()
{
                   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_4_1238(               A&);
two   sink_4_1238(const          A&);
three sink_4_1238(volatile       A&);
eight sink_4_1238(const volatile A&&);
 
int test4_1238()
{
                   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_4_1245(               A&);
two   sink_4_1245(const          A&);
four  sink_4_1245(const volatile A&);
five  sink_4_1245(               A&&);
 
int test4_1245()
{
                   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_4_1246(               A&);
two   sink_4_1246(const          A&);
four  sink_4_1246(const volatile A&);
six   sink_4_1246(const          A&&);
 
int test4_1246()
{
                   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_4_1247(               A&);
two   sink_4_1247(const          A&);
four  sink_4_1247(const volatile A&);
seven sink_4_1247(volatile       A&&);
 
int test4_1247()
{
                   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_4_1248(               A&);
two   sink_4_1248(const          A&);
four  sink_4_1248(const volatile A&);
eight sink_4_1248(const volatile A&&);
 
int test4_1248()
{
                   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_4_1256(               A&);
two   sink_4_1256(const          A&);
five  sink_4_1256(               A&&);
six   sink_4_1256(const          A&&);
 
int test4_1256()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_4_1257(               A&);
two   sink_4_1257(const          A&);
five  sink_4_1257(               A&&);
seven sink_4_1257(volatile       A&&);
 
int test4_1257()
{
                   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_4_1258(               A&);
two   sink_4_1258(const          A&);
five  sink_4_1258(               A&&);
eight sink_4_1258(const volatile A&&);
 
int test4_1258()
{
                   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_4_1267(               A&);
two   sink_4_1267(const          A&);
six   sink_4_1267(const          A&&);
seven sink_4_1267(volatile       A&&);
 
int test4_1267()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_4_1268(               A&);
two   sink_4_1268(const          A&);
six   sink_4_1268(const          A&&);
eight sink_4_1268(const volatile A&&);
 
int test4_1268()
{
                   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_4_1278(               A&);
two   sink_4_1278(const          A&);
seven sink_4_1278(volatile       A&&);
eight sink_4_1278(const volatile A&&);
 
int test4_1278()
{
                   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_4_1345(               A&);
three sink_4_1345(volatile       A&);
four  sink_4_1345(const volatile A&);
five  sink_4_1345(               A&&);
 
int test4_1345()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t2;
    sa t3;
    sa t4;
    sa t5;
    return 0;
}
 
one   sink_4_1346(               A&);
three sink_4_1346(volatile       A&);
four  sink_4_1346(const volatile A&);
six   sink_4_1346(const          A&&);
 
int test4_1346()
{
                   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_4_1347(               A&);
three sink_4_1347(volatile       A&);
four  sink_4_1347(const volatile A&);
seven sink_4_1347(volatile       A&&);
 
int test4_1347()
{
                   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_4_1348(               A&);
three sink_4_1348(volatile       A&);
four  sink_4_1348(const volatile A&);
eight sink_4_1348(const volatile A&&);
 
int test4_1348()
{
                   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_4_1356(               A&);
three sink_4_1356(volatile       A&);
five  sink_4_1356(               A&&);
six   sink_4_1356(const          A&&);
 
int test4_1356()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
one   sink_4_1357(               A&);
three sink_4_1357(volatile       A&);
five  sink_4_1357(               A&&);
seven sink_4_1357(volatile       A&&);
 
int test4_1357()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t5;
    sa t7;
    return 0;
}
 
one   sink_4_1358(               A&);
three sink_4_1358(volatile       A&);
five  sink_4_1358(               A&&);
eight sink_4_1358(const volatile A&&);
 
int test4_1358()
{
                   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_4_1367(               A&);
three sink_4_1367(volatile       A&);
six   sink_4_1367(const          A&&);
seven sink_4_1367(volatile       A&&);
 
int test4_1367()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t3;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_4_1368(               A&);
three sink_4_1368(volatile       A&);
six   sink_4_1368(const          A&&);
eight sink_4_1368(const volatile A&&);
 
int test4_1368()
{
                   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_4_1378(               A&);
three sink_4_1378(volatile       A&);
seven sink_4_1378(volatile       A&&);
eight sink_4_1378(const volatile A&&);
 
int test4_1378()
{
                   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_4_1456(               A&);
four  sink_4_1456(const volatile A&);
five  sink_4_1456(               A&&);
six   sink_4_1456(const          A&&);
 
int test4_1456()
{
                   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_4_1457(               A&);
four  sink_4_1457(const volatile A&);
five  sink_4_1457(               A&&);
seven sink_4_1457(volatile       A&&);
 
int test4_1457()
{
                   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_4_1458(               A&);
four  sink_4_1458(const volatile A&);
five  sink_4_1458(               A&&);
eight sink_4_1458(const volatile A&&);
 
int test4_1458()
{
                   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_4_1467(               A&);
four  sink_4_1467(const volatile A&);
six   sink_4_1467(const          A&&);
seven sink_4_1467(volatile       A&&);
 
int test4_1467()
{
                   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_4_1468(               A&);
four  sink_4_1468(const volatile A&);
six   sink_4_1468(const          A&&);
eight sink_4_1468(const volatile A&&);
 
int test4_1468()
{
                   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_4_1478(               A&);
four  sink_4_1478(const volatile A&);
seven sink_4_1478(volatile       A&&);
eight sink_4_1478(const volatile A&&);
 
int test4_1478()
{
                   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_4_1567(               A&);
five  sink_4_1567(               A&&);
six   sink_4_1567(const          A&&);
seven sink_4_1567(volatile       A&&);
 
int test4_1567()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t5;
    sa t6;
    sa t7;
    return 0;
}
 
one   sink_4_1568(               A&);
five  sink_4_1568(               A&&);
six   sink_4_1568(const          A&&);
eight sink_4_1568(const volatile A&&);
 
int test4_1568()
{
                   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;
}
 
one   sink_4_1578(               A&);
five  sink_4_1578(               A&&);
seven sink_4_1578(volatile       A&&);
eight sink_4_1578(const volatile A&&);
 
int test4_1578()
{
                   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;
}
 
one   sink_4_1678(               A&);
six   sink_4_1678(const          A&&);
seven sink_4_1678(volatile       A&&);
eight sink_4_1678(const volatile A&&);
 
int test4_1678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t1;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
two   sink_4_2345(const          A&);
three sink_4_2345(volatile       A&);
four  sink_4_2345(const volatile A&);
five  sink_4_2345(               A&&);
 
int test4_2345()
{
                   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_4_2346(const          A&);
three sink_4_2346(volatile       A&);
four  sink_4_2346(const volatile A&);
six   sink_4_2346(const          A&&);
 
int test4_2346()
{
                   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_4_2347(const          A&);
three sink_4_2347(volatile       A&);
four  sink_4_2347(const volatile A&);
seven sink_4_2347(volatile       A&&);
 
int test4_2347()
{
                   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_4_2348(const          A&);
three sink_4_2348(volatile       A&);
four  sink_4_2348(const volatile A&);
eight sink_4_2348(const volatile A&&);
 
int test4_2348()
{
                   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_4_2356(const          A&);
three sink_4_2356(volatile       A&);
five  sink_4_2356(               A&&);
six   sink_4_2356(const          A&&);
 
int test4_2356()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t5;
    sa t6;
    return 0;
}
 
two   sink_4_2357(const          A&);
three sink_4_2357(volatile       A&);
five  sink_4_2357(               A&&);
seven sink_4_2357(volatile       A&&);
 
int test4_2357()
{
                   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_4_2358(const          A&);
three sink_4_2358(volatile       A&);
five  sink_4_2358(               A&&);
eight sink_4_2358(const volatile A&&);
 
int test4_2358()
{
                   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_4_2367(const          A&);
three sink_4_2367(volatile       A&);
six   sink_4_2367(const          A&&);
seven sink_4_2367(volatile       A&&);
 
int test4_2367()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t2;
    sa t3;
    sa t6;
    sa t7;
    return 0;
}
 
two   sink_4_2368(const          A&);
three sink_4_2368(volatile       A&);
six   sink_4_2368(const          A&&);
eight sink_4_2368(const volatile A&&);
 
int test4_2368()
{
                   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_4_2378(const          A&);
three sink_4_2378(volatile       A&);
seven sink_4_2378(volatile       A&&);
eight sink_4_2378(const volatile A&&);
 
int test4_2378()
{
                   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_4_2456(const          A&);
four  sink_4_2456(const volatile A&);
five  sink_4_2456(               A&&);
six   sink_4_2456(const          A&&);
 
int test4_2456()
{
                   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;
}
 
two   sink_4_2457(const          A&);
four  sink_4_2457(const volatile A&);
five  sink_4_2457(               A&&);
seven sink_4_2457(volatile       A&&);
 
int test4_2457()
{
                   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_4_2458(const          A&);
four  sink_4_2458(const volatile A&);
five  sink_4_2458(               A&&);
eight sink_4_2458(const volatile A&&);
 
int test4_2458()
{
                   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_4_2467(const          A&);
four  sink_4_2467(const volatile A&);
six   sink_4_2467(const          A&&);
seven sink_4_2467(volatile       A&&);
 
int test4_2467()
{
                   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;
}
 
two   sink_4_2468(const          A&);
four  sink_4_2468(const volatile A&);
six   sink_4_2468(const          A&&);
eight sink_4_2468(const volatile A&&);
 
int test4_2468()
{
                   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_4_2478(const          A&);
four  sink_4_2478(const volatile A&);
seven sink_4_2478(volatile       A&&);
eight sink_4_2478(const volatile A&&);
 
int test4_2478()
{
                   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_4_2567(const          A&);
five  sink_4_2567(               A&&);
six   sink_4_2567(const          A&&);
seven sink_4_2567(volatile       A&&);
 
int test4_2567()
{
                   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;
}
 
two   sink_4_2568(const          A&);
five  sink_4_2568(               A&&);
six   sink_4_2568(const          A&&);
eight sink_4_2568(const volatile A&&);
 
int test4_2568()
{
                   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;
}
 
two   sink_4_2578(const          A&);
five  sink_4_2578(               A&&);
seven sink_4_2578(volatile       A&&);
eight sink_4_2578(const volatile A&&);
 
int test4_2578()
{
                   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;
}
 
two   sink_4_2678(const          A&);
six   sink_4_2678(const          A&&);
seven sink_4_2678(volatile       A&&);
eight sink_4_2678(const volatile A&&);
 
int test4_2678()
{
                   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;
}
 
three sink_4_3456(volatile       A&);
four  sink_4_3456(const volatile A&);
five  sink_4_3456(               A&&);
six   sink_4_3456(const          A&&);
 
int test4_3456()
{
                   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;
}
 
three sink_4_3457(volatile       A&);
four  sink_4_3457(const volatile A&);
five  sink_4_3457(               A&&);
seven sink_4_3457(volatile       A&&);
 
int test4_3457()
{
                   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;
}
 
three sink_4_3458(volatile       A&);
four  sink_4_3458(const volatile A&);
five  sink_4_3458(               A&&);
eight sink_4_3458(const volatile A&&);
 
int test4_3458()
{
                   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_4_3467(volatile       A&);
four  sink_4_3467(const volatile A&);
six   sink_4_3467(const          A&&);
seven sink_4_3467(volatile       A&&);
 
int test4_3467()
{
                   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;
}
 
three sink_4_3468(volatile       A&);
four  sink_4_3468(const volatile A&);
six   sink_4_3468(const          A&&);
eight sink_4_3468(const volatile A&&);
 
int test4_3468()
{
                   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_4_3478(volatile       A&);
four  sink_4_3478(const volatile A&);
seven sink_4_3478(volatile       A&&);
eight sink_4_3478(const volatile A&&);
 
int test4_3478()
{
                   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_4_3567(volatile       A&);
five  sink_4_3567(               A&&);
six   sink_4_3567(const          A&&);
seven sink_4_3567(volatile       A&&);
 
int test4_3567()
{
                   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;
}
 
three sink_4_3568(volatile       A&);
five  sink_4_3568(               A&&);
six   sink_4_3568(const          A&&);
eight sink_4_3568(const volatile A&&);
 
int test4_3568()
{
                   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;
}
 
three sink_4_3578(volatile       A&);
five  sink_4_3578(               A&&);
seven sink_4_3578(volatile       A&&);
eight sink_4_3578(const volatile A&&);
 
int test4_3578()
{
                   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;
}
 
three sink_4_3678(volatile       A&);
six   sink_4_3678(const          A&&);
seven sink_4_3678(volatile       A&&);
eight sink_4_3678(const volatile A&&);
 
int test4_3678()
{
                   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;
}
 
four  sink_4_4567(const volatile A&);
five  sink_4_4567(               A&&);
six   sink_4_4567(const          A&&);
seven sink_4_4567(volatile       A&&);
 
int test4_4567()
{
                   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;
}
 
four  sink_4_4568(const volatile A&);
five  sink_4_4568(               A&&);
six   sink_4_4568(const          A&&);
eight sink_4_4568(const volatile A&&);
 
int test4_4568()
{
                   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;
}
 
four  sink_4_4578(const volatile A&);
five  sink_4_4578(               A&&);
seven sink_4_4578(volatile       A&&);
eight sink_4_4578(const volatile A&&);
 
int test4_4578()
{
                   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;
}
 
four  sink_4_4678(const volatile A&);
six   sink_4_4678(const          A&&);
seven sink_4_4678(volatile       A&&);
eight sink_4_4678(const volatile A&&);
 
int test4_4678()
{
                   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;
}
 
five  sink_4_5678(               A&&);
six   sink_4_5678(const          A&&);
seven sink_4_5678(volatile       A&&);
eight sink_4_5678(const volatile A&&);
 
int test4_5678()
{
                   A a;
    const          A ca = a;
          volatile A va;
    const volatile A cva = a;
    sa t5;
    sa t6;
    sa t7;
    sa t8;
    return 0;
}
 
int main()
{
    return test4_1234() + test4_1235() + test4_1236() + test4_1237() + test4_1238() +
           test4_1245() + test4_1246() + test4_1247() + test4_1248() + test4_1256() +
           test4_1257() + test4_1258() + test4_1267() + test4_1268() + test4_1278() +
           test4_1345() + test4_1346() + test4_1347() + test4_1348() + test4_1356() +
           test4_1357() + test4_1358() + test4_1367() + test4_1368() + test4_1378() +
           test4_1456() + test4_1457() + test4_1458() + test4_1467() + test4_1468() +
           test4_1478() + test4_1567() + test4_1568() + test4_1578() + test4_1678() +
           test4_2345() + test4_2346() + test4_2347() + test4_2348() + test4_2356() +
           test4_2357() + test4_2358() + test4_2367() + test4_2368() + test4_2378() +
           test4_2456() + test4_2457() + test4_2458() + test4_2467() + test4_2468() +
           test4_2478() + test4_2567() + test4_2568() + test4_2578() + test4_2678() +
           test4_3456() + test4_3457() + test4_3458() + test4_3467() + test4_3468() +
           test4_3478() + test4_3567() + test4_3568() + test4_3578() + test4_3678() +
           test4_4567() + test4_4568() + test4_4578() + test4_4678() + test4_5678();
}

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

Browse

Tools

Subversion Repositories openrisc_me

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