URL https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [rv4p.C] - Blame information for rev 774

Go to most recent revision | 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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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;
          volatile A va;
    const volatile A cva;
    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();
}
Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [cpp0x/] [rv4p.C] - Blame information for rev 774

Line No.	Rev	Author	Line
1	693	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			`struct one {long x[1];};`
12			`struct two {long x[2];};`
13			`struct three {long x[3];};`
14			`struct four {long x[4];};`
15			`struct five {long x[5];};`
16			`struct six {long x[6];};`
17			`struct seven {long x[7];};`
18			`struct eight {long x[8];};`
19
20			`struct A`
21			`{`
22			`A();`
23			`A(const volatile A&&);`
24			`};`
25
26			`A source();`
27			`const A c_source();`
28			`volatile A v_source();`
29			`const volatile A cv_source();`
30
31			`// 4 at a time`
32
33			`one sink_4_1234( A&);`
34			`two sink_4_1234(const A&);`
35			`three sink_4_1234(volatile A&);`
36			`four sink_4_1234(const volatile A&);`
37
38			`int test4_1234()`
39			`{`
40			`A a;`