rv5p.c

来自「用于进行gcc测试」· C语言 代码 · 共 1,284 行 · 第 1/3 页

          volatile A va;
    const volatile A cva = a;
    sa<sizeof(sink_5_23458(ca))          == 2> t2;
    sa<sizeof(sink_5_23458(va))          == 3> t3;
    sa<sizeof(sink_5_23458(cva))         == 4> t4;
    sa<sizeof(sink_5_23458(source()))    == 5> t5;
    sa<sizeof(sink_5_23458(c_source()))  == 8> t6;
    sa<sizeof(sink_5_23458(v_source()))  == 8> t7;
    sa<sizeof(sink_5_23458(cv_source())) == 8> 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<sizeof(sink_5_23467(ca))          == 2> t2;
    sa<sizeof(sink_5_23467(va))          == 3> t3;
    sa<sizeof(sink_5_23467(cva))         == 4> t4;
    sa<sizeof(sink_5_23467(c_source()))  == 6> t6;
    sa<sizeof(sink_5_23467(v_source()))  == 7> 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<sizeof(sink_5_23468(ca))          == 2> t2;
    sa<sizeof(sink_5_23468(va))          == 3> t3;
    sa<sizeof(sink_5_23468(cva))         == 4> t4;
    sa<sizeof(sink_5_23468(source()))    == 6> t5;
    sa<sizeof(sink_5_23468(c_source()))  == 6> t6;
    sa<sizeof(sink_5_23468(v_source()))  == 8> t7;
    sa<sizeof(sink_5_23468(cv_source())) == 8> 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<sizeof(sink_5_23478(ca))          == 2> t2;
    sa<sizeof(sink_5_23478(va))          == 3> t3;
    sa<sizeof(sink_5_23478(cva))         == 4> t4;
    sa<sizeof(sink_5_23478(source()))    == 7> t5;
    sa<sizeof(sink_5_23478(c_source()))  == 8> t6;
    sa<sizeof(sink_5_23478(v_source()))  == 7> t7;
    sa<sizeof(sink_5_23478(cv_source())) == 8> 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<sizeof(sink_5_23567(ca))          == 2> t2;
    sa<sizeof(sink_5_23567(va))          == 3> t3;
    sa<sizeof(sink_5_23567(source()))    == 5> t5;
    sa<sizeof(sink_5_23567(c_source()))  == 6> t6;
    sa<sizeof(sink_5_23567(v_source()))  == 7> 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<sizeof(sink_5_23568(ca))          == 2> t2;
    sa<sizeof(sink_5_23568(va))          == 3> t3;
    sa<sizeof(sink_5_23568(cva))         == 8> t4;
    sa<sizeof(sink_5_23568(source()))    == 5> t5;
    sa<sizeof(sink_5_23568(c_source()))  == 6> t6;
    sa<sizeof(sink_5_23568(v_source()))  == 8> t7;
    sa<sizeof(sink_5_23568(cv_source())) == 8> 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<sizeof(sink_5_23578(ca))          == 2> t2;
    sa<sizeof(sink_5_23578(va))          == 3> t3;
    sa<sizeof(sink_5_23578(cva))         == 8> t4;
    sa<sizeof(sink_5_23578(source()))    == 5> t5;
    sa<sizeof(sink_5_23578(c_source()))  == 8> t6;
    sa<sizeof(sink_5_23578(v_source()))  == 7> t7;
    sa<sizeof(sink_5_23578(cv_source())) == 8> 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<sizeof(sink_5_23678(ca))          == 2> t2;
    sa<sizeof(sink_5_23678(va))          == 3> t3;
    sa<sizeof(sink_5_23678(cva))         == 8> t4;
    sa<sizeof(sink_5_23678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_23678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_23678(cv_source())) == 8> 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<sizeof(sink_5_24567(a))           == 2> t1;
    sa<sizeof(sink_5_24567(ca))          == 2> t2;
    sa<sizeof(sink_5_24567(va))          == 4> t3;
    sa<sizeof(sink_5_24567(cva))         == 4> t4;
    sa<sizeof(sink_5_24567(source()))    == 5> t5;
    sa<sizeof(sink_5_24567(c_source()))  == 6> t6;
    sa<sizeof(sink_5_24567(v_source()))  == 7> 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<sizeof(sink_5_24568(a))           == 2> t1;
    sa<sizeof(sink_5_24568(ca))          == 2> t2;
    sa<sizeof(sink_5_24568(va))          == 4> t3;
    sa<sizeof(sink_5_24568(cva))         == 4> t4;
    sa<sizeof(sink_5_24568(source()))    == 5> t5;
    sa<sizeof(sink_5_24568(c_source()))  == 6> t6;
    sa<sizeof(sink_5_24568(v_source()))  == 8> t7;
    sa<sizeof(sink_5_24568(cv_source())) == 8> 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<sizeof(sink_5_24578(a))           == 2> t1;
    sa<sizeof(sink_5_24578(ca))          == 2> t2;
    sa<sizeof(sink_5_24578(va))          == 4> t3;
    sa<sizeof(sink_5_24578(cva))         == 4> t4;
    sa<sizeof(sink_5_24578(source()))    == 5> t5;
    sa<sizeof(sink_5_24578(c_source()))  == 8> t6;
    sa<sizeof(sink_5_24578(v_source()))  == 7> t7;
    sa<sizeof(sink_5_24578(cv_source())) == 8> 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<sizeof(sink_5_24678(a))           == 2> t1;
    sa<sizeof(sink_5_24678(ca))          == 2> t2;
    sa<sizeof(sink_5_24678(va))          == 4> t3;
    sa<sizeof(sink_5_24678(cva))         == 4> t4;
    sa<sizeof(sink_5_24678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_24678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_24678(cv_source())) == 8> 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<sizeof(sink_5_25678(a))           == 2> t1;
    sa<sizeof(sink_5_25678(ca))          == 2> t2;
    sa<sizeof(sink_5_25678(va))          == 7> t3;
    sa<sizeof(sink_5_25678(cva))         == 8> t4;
    sa<sizeof(sink_5_25678(source()))    == 5> t5;
    sa<sizeof(sink_5_25678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_25678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_25678(cv_source())) == 8> 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<sizeof(sink_5_34567(a))           == 3> t1;
    sa<sizeof(sink_5_34567(ca))          == 4> t2;
    sa<sizeof(sink_5_34567(va))          == 3> t3;
    sa<sizeof(sink_5_34567(cva))         == 4> t4;
    sa<sizeof(sink_5_34567(source()))    == 5> t5;
    sa<sizeof(sink_5_34567(c_source()))  == 6> t6;
    sa<sizeof(sink_5_34567(v_source()))  == 7> 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<sizeof(sink_5_34568(a))           == 3> t1;
    sa<sizeof(sink_5_34568(ca))          == 4> t2;
    sa<sizeof(sink_5_34568(va))          == 3> t3;
    sa<sizeof(sink_5_34568(cva))         == 4> t4;
    sa<sizeof(sink_5_34568(source()))    == 5> t5;
    sa<sizeof(sink_5_34568(c_source()))  == 6> t6;
    sa<sizeof(sink_5_34568(v_source()))  == 8> t7;
    sa<sizeof(sink_5_34568(cv_source())) == 8> 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<sizeof(sink_5_34578(a))           == 3> t1;
    sa<sizeof(sink_5_34578(ca))          == 4> t2;
    sa<sizeof(sink_5_34578(va))          == 3> t3;
    sa<sizeof(sink_5_34578(cva))         == 4> t4;
    sa<sizeof(sink_5_34578(source()))    == 5> t5;
    sa<sizeof(sink_5_34578(c_source()))  == 8> t6;
    sa<sizeof(sink_5_34578(v_source()))  == 7> t7;
    sa<sizeof(sink_5_34578(cv_source())) == 8> 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<sizeof(sink_5_34678(a))           == 3> t1;
    sa<sizeof(sink_5_34678(ca))          == 4> t2;
    sa<sizeof(sink_5_34678(va))          == 3> t3;
    sa<sizeof(sink_5_34678(cva))         == 4> t4;
    sa<sizeof(sink_5_34678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_34678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_34678(cv_source())) == 8> 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<sizeof(sink_5_35678(a))           == 3> t1;
    sa<sizeof(sink_5_35678(ca))          == 6> t2;
    sa<sizeof(sink_5_35678(va))          == 3> t3;
    sa<sizeof(sink_5_35678(cva))         == 8> t4;
    sa<sizeof(sink_5_35678(source()))    == 5> t5;
    sa<sizeof(sink_5_35678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_35678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_35678(cv_source())) == 8> 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<sizeof(sink_5_45678(a))           == 4> t1;
    sa<sizeof(sink_5_45678(ca))          == 4> t2;
    sa<sizeof(sink_5_45678(va))          == 4> t3;
    sa<sizeof(sink_5_45678(cva))         == 4> t4;
    sa<sizeof(sink_5_45678(source()))    == 5> t5;
    sa<sizeof(sink_5_45678(c_source()))  == 6> t6;
    sa<sizeof(sink_5_45678(v_source()))  == 7> t7;
    sa<sizeof(sink_5_45678(cv_source())) == 8> 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();
}