rv4p.c

用于进行gcc测试

}

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<sizeof(sink_4_1347(a))           == 1> t1;
    sa<sizeof(sink_4_1347(ca))          == 4> t2;
    sa<sizeof(sink_4_1347(va))          == 3> t3;
    sa<sizeof(sink_4_1347(cva))         == 4> t4;
    sa<sizeof(sink_4_1347(source()))    == 7> t5;
    sa<sizeof(sink_4_1347(v_source()))  == 7> 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<sizeof(sink_4_1348(a))           == 1> t1;
    sa<sizeof(sink_4_1348(ca))          == 4> t2;
    sa<sizeof(sink_4_1348(va))          == 3> t3;
    sa<sizeof(sink_4_1348(cva))         == 4> t4;
    sa<sizeof(sink_4_1348(source()))    == 8> t5;
    sa<sizeof(sink_4_1348(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1348(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1348(cv_source())) == 8> 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<sizeof(sink_4_1356(a))           == 1> t1;
    sa<sizeof(sink_4_1356(ca))          == 6> t2;
    sa<sizeof(sink_4_1356(va))          == 3> t3;
    sa<sizeof(sink_4_1356(source()))    == 5> t5;
    sa<sizeof(sink_4_1356(c_source()))  == 6> 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<sizeof(sink_4_1357(a))           == 1> t1;
    sa<sizeof(sink_4_1357(va))          == 3> t3;
    sa<sizeof(sink_4_1357(source()))    == 5> t5;
    sa<sizeof(sink_4_1357(v_source()))  == 7> 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<sizeof(sink_4_1358(a))           == 1> t1;
    sa<sizeof(sink_4_1358(ca))          == 8> t2;
    sa<sizeof(sink_4_1358(va))          == 3> t3;
    sa<sizeof(sink_4_1358(cva))         == 8> t4;
    sa<sizeof(sink_4_1358(source()))    == 5> t5;
    sa<sizeof(sink_4_1358(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1358(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1358(cv_source())) == 8> 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<sizeof(sink_4_1367(a))           == 1> t1;
    sa<sizeof(sink_4_1367(ca))          == 6> t2;
    sa<sizeof(sink_4_1367(va))          == 3> t3;
    sa<sizeof(sink_4_1367(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1367(v_source()))  == 7> 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<sizeof(sink_4_1368(a))           == 1> t1;
    sa<sizeof(sink_4_1368(ca))          == 6> t2;
    sa<sizeof(sink_4_1368(va))          == 3> t3;
    sa<sizeof(sink_4_1368(cva))         == 8> t4;
    sa<sizeof(sink_4_1368(source()))    == 6> t5;
    sa<sizeof(sink_4_1368(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1368(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1368(cv_source())) == 8> 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<sizeof(sink_4_1378(a))           == 1> t1;
    sa<sizeof(sink_4_1378(ca))          == 8> t2;
    sa<sizeof(sink_4_1378(va))          == 3> t3;
    sa<sizeof(sink_4_1378(cva))         == 8> t4;
    sa<sizeof(sink_4_1378(source()))    == 7> t5;
    sa<sizeof(sink_4_1378(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1378(v_source()))  == 7> t7;
    sa<sizeof(sink_4_1378(cv_source())) == 8> 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<sizeof(sink_4_1456(a))           == 1> t1;
    sa<sizeof(sink_4_1456(ca))          == 4> t2;
    sa<sizeof(sink_4_1456(va))          == 4> t3;
    sa<sizeof(sink_4_1456(cva))         == 4> t4;
    sa<sizeof(sink_4_1456(source()))    == 5> t5;
    sa<sizeof(sink_4_1456(c_source()))  == 6> 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<sizeof(sink_4_1457(a))           == 1> t1;
    sa<sizeof(sink_4_1457(ca))          == 4> t2;
    sa<sizeof(sink_4_1457(va))          == 4> t3;
    sa<sizeof(sink_4_1457(cva))         == 4> t4;
    sa<sizeof(sink_4_1457(source()))    == 5> t5;
    sa<sizeof(sink_4_1457(v_source()))  == 7> 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<sizeof(sink_4_1458(a))           == 1> t1;
    sa<sizeof(sink_4_1458(ca))          == 4> t2;
    sa<sizeof(sink_4_1458(va))          == 4> t3;
    sa<sizeof(sink_4_1458(cva))         == 4> t4;
    sa<sizeof(sink_4_1458(source()))    == 5> t5;
    sa<sizeof(sink_4_1458(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1458(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1458(cv_source())) == 8> 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<sizeof(sink_4_1467(a))           == 1> t1;
    sa<sizeof(sink_4_1467(ca))          == 4> t2;
    sa<sizeof(sink_4_1467(va))          == 4> t3;
    sa<sizeof(sink_4_1467(cva))         == 4> t4;
    sa<sizeof(sink_4_1467(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1467(v_source()))  == 7> 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<sizeof(sink_4_1468(a))           == 1> t1;
    sa<sizeof(sink_4_1468(ca))          == 4> t2;
    sa<sizeof(sink_4_1468(va))          == 4> t3;
    sa<sizeof(sink_4_1468(cva))         == 4> t4;
    sa<sizeof(sink_4_1468(source()))    == 6> t5;
    sa<sizeof(sink_4_1468(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1468(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1468(cv_source())) == 8> 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<sizeof(sink_4_1478(a))           == 1> t1;
    sa<sizeof(sink_4_1478(ca))          == 4> t2;
    sa<sizeof(sink_4_1478(va))          == 4> t3;
    sa<sizeof(sink_4_1478(cva))         == 4> t4;
    sa<sizeof(sink_4_1478(source()))    == 7> t5;
    sa<sizeof(sink_4_1478(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1478(v_source()))  == 7> t7;
    sa<sizeof(sink_4_1478(cv_source())) == 8> 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<sizeof(sink_4_1567(a))           == 1> t1;
    sa<sizeof(sink_4_1567(ca))          == 6> t2;
    sa<sizeof(sink_4_1567(va))          == 7> t3;
    sa<sizeof(sink_4_1567(source()))    == 5> t5;
    sa<sizeof(sink_4_1567(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1567(v_source()))  == 7> 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<sizeof(sink_4_1568(a))           == 1> t1;
    sa<sizeof(sink_4_1568(ca))          == 6> t2;
    sa<sizeof(sink_4_1568(va))          == 8> t3;
    sa<sizeof(sink_4_1568(cva))         == 8> t4;
    sa<sizeof(sink_4_1568(source()))    == 5> t5;
    sa<sizeof(sink_4_1568(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1568(v_source()))  == 8> t7;
    sa<sizeof(sink_4_1568(cv_source())) == 8> 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<sizeof(sink_4_1578(a))           == 1> t1;
    sa<sizeof(sink_4_1578(ca))          == 8> t2;
    sa<sizeof(sink_4_1578(va))          == 7> t3;
    sa<sizeof(sink_4_1578(cva))         == 8> t4;
    sa<sizeof(sink_4_1578(source()))    == 5> t5;
    sa<sizeof(sink_4_1578(c_source()))  == 8> t6;
    sa<sizeof(sink_4_1578(v_source()))  == 7> t7;
    sa<sizeof(sink_4_1578(cv_source())) == 8> 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<sizeof(sink_4_1678(a))           == 1> t1;
    sa<sizeof(sink_4_1678(ca))          == 6> t2;
    sa<sizeof(sink_4_1678(va))          == 7> t3;
    sa<sizeof(sink_4_1678(cva))         == 8> t4;
    sa<sizeof(sink_4_1678(c_source()))  == 6> t6;
    sa<sizeof(sink_4_1678(v_source()))  == 7> t7;
    sa<sizeof(sink_4_1678(cv_source())) == 8> t8;
    return 0;