Ignore:
Timestamp:
Sep 9, 2003, 8:27:08 PM (22 years ago)
Author:
bird
Message:

More stuff.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/testcase/631main.c

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.2
    r674 r675  
    1212 */
    1313
    14 
     14/*******************************************************************************
     15*   Defined Constants And Macros                                               *
     16*******************************************************************************/
     17#if defined(__IBMC__) || defined(__IBMCPP__)
     18#define DEF(a) a##_vac
     19#else
     20#define DEF(a) a##_gcc
     21#endif
    1522
    1623       
    … …  
    4249*   External Functions                                                         *
    4350*******************************************************************************/
    44 extern struct ret4bytes _System    asmfoo4(void);
    45 extern struct ret8bytes _System    asmfoo8(void);
    46 extern struct ret12bytes _System   asmfoo12(void);
    47 extern struct ret16bytes _System   asmfoo16(void);
    48 
    49 struct ret4bytes _System    foo4(void)
     51extern struct ret4bytes _System    asmfoosys4(void);
     52extern struct ret8bytes _System    asmfoosys8(void);
     53extern struct ret12bytes _System   asmfoosys12(void);
     54extern struct ret16bytes _System   asmfoosys16(void);
     55extern struct ret4bytes _Optlink   asmfooopt4(void);
     56extern struct ret8bytes _Optlink   asmfooopt8(void);
     57extern struct ret12bytes _Optlink  asmfooopt12(void);
     58extern struct ret16bytes _Optlink  asmfooopt16(void);
     59extern struct ret4bytes __stdcall  asmfoostd4(void);
     60extern struct ret8bytes __stdcall  asmfoostd8(void);
     61extern struct ret12bytes __stdcall asmfoostd12(void);
     62extern struct ret16bytes __stdcall asmfoostd16(void);
     63extern struct ret4bytes            DEF(asmfoodef4)(void);
     64extern struct ret8bytes            DEF(asmfoodef8)(void);
     65extern struct ret12bytes           DEF(asmfoodef12)(void);
     66extern struct ret16bytes           DEF(asmfoodef16)(void);
     67
     68struct ret4bytes _System    foosys4(void)
    5069{
    5170    struct ret4bytes ret = {1};
    … …  
    5372}
    5473
    55 struct ret8bytes _System    foo8(void)
     74struct ret8bytes _System    foosys8(void)
    5675{
    5776    struct ret8bytes ret = {1,2};
    … …  
    5978}
    6079
    61 struct ret12bytes _System   foo12(void)
     80struct ret12bytes _System   foosys12(void)
    6281{
    6382    struct ret12bytes ret = {1,2,3};
    … …  
    6584}
    6685
    67 struct ret16bytes _System   foo16(void)
     86struct ret16bytes _System   foosys16(void)
    6887{
    6988    struct ret16bytes ret = {1,2,3,4};
    7089    return ret;
    7190}
     91
     92/* optlink */
     93struct ret4bytes _Optlink   fooopt4(void)
     94{
     95    struct ret4bytes ret = {1};
     96    return ret;
     97}
     98
     99struct ret8bytes _Optlink   fooopt8(void)
     100{
     101    struct ret8bytes ret = {1,2};
     102    return ret;
     103}
     104
     105struct ret12bytes _Optlink  fooopt12(void)
     106{
     107    struct ret12bytes ret = {1,2,3};
     108    return ret;
     109}
     110
     111struct ret16bytes _Optlink  fooopt16(void)
     112{
     113    struct ret16bytes ret = {1,2,3,4};
     114    return ret;
     115}
     116
     117
     118/* stdcall */
     119struct ret4bytes __stdcall  foostd4(void)
     120{
     121    struct ret4bytes ret = {1};
     122    return ret;
     123}
     124
     125struct ret8bytes __stdcall  foostd8(void)
     126{
     127    struct ret8bytes ret = {1,2};
     128    return ret;
     129}
     130
     131struct ret12bytes __stdcall foostd12(void)
     132{
     133    struct ret12bytes ret = {1,2,3};
     134    return ret;
     135}
     136
     137struct ret16bytes __stdcall foostd16(void)
     138{
     139    struct ret16bytes ret = {1,2,3,4};
     140    return ret;
     141}
     142
     143
     144
     145/* default */
     146struct ret4bytes    foodef4(void)
     147{
     148    struct ret4bytes ret = {1};
     149    return ret;
     150}
     151
     152struct ret8bytes    foodef8(void)
     153{
     154    struct ret8bytes ret = {1,2};
     155    return ret;
     156}
     157
     158struct ret12bytes   foodef12(void)
     159{
     160    struct ret12bytes ret = {1,2,3};
     161    return ret;
     162}
     163
     164struct ret16bytes   foodef16(void)
     165{
     166    struct ret16bytes ret = {1,2,3,4};
     167    return ret;
     168}
     169
     170
    72171
    73172
    … …  
    83182    /* gcc */
    84183    memset(&rc4, 0, sizeof(rc4));
    85     rc4 = foo4();
    86     if (rc4.au[0] != 1)
    87     {
    88         printf("631main: foo4 failed\n");
    89         rcRet++;
    90     }
    91 
    92     memset(&rc8, 0, sizeof(rc8));
    93     rc8 = foo8();
    94     if (rc8.au[0] != 1 && rc8.au[1] != 2)
    95     {
    96         printf("631main: foo8 failed\n");
    97         rcRet++;
    98     }
    99 
    100     memset(&rc12, 0, sizeof(rc12));
    101     rc12 = foo12();
    102     if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
    103     {
    104         printf("631main: foo12 failed\n");
    105         rcRet++;
    106     }
    107 
    108     memset(&rc16, 0, sizeof(rc16));
    109     rc16 = foo16();
    110     if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
    111     {
    112         printf("631main: foo12 failed\n");
     184    rc4 = foosys4();
     185    if (rc4.au[0] != 1)
     186    {
     187        printf("631main: foosys4 failed\n");
     188        rcRet++;
     189    }
     190
     191    memset(&rc8, 0, sizeof(rc8));
     192    rc8 = foosys8();
     193    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     194    {
     195        printf("631main: foosys8 failed\n");
     196        rcRet++;
     197    }
     198
     199    memset(&rc12, 0, sizeof(rc12));
     200    rc12 = foosys12();
     201    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     202    {
     203        printf("631main: foosys12 failed\n");
     204        rcRet++;
     205    }
     206
     207    memset(&rc16, 0, sizeof(rc16));
     208    rc16 = foosys16();
     209    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     210    {
     211        printf("631main: foosys12 failed\n");
    113212        rcRet++;
    114213    }
    … …  
    116215    /* asm */
    117216    memset(&rc4, 0, sizeof(rc4));
    118     rc4 = asmfoo4();
    119     if (rc4.au[0] != 1)
    120     {
    121         printf("631main: asmfoo4 failed\n");
    122         rcRet++;
    123     }
    124 
    125     memset(&rc8, 0, sizeof(rc8));
    126     rc8 = asmfoo8();
    127     if (rc8.au[0] != 1 && rc8.au[1] != 2)
    128     {
    129         printf("631main: asmfoo8 failed\n");
    130         rcRet++;
    131     }
    132 
    133     memset(&rc12, 0, sizeof(rc12));
    134     rc12 = asmfoo12();
    135     if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
    136     {
    137         printf("631main: asmfoo12 failed\n");
    138         rcRet++;
    139     }
    140 
    141     memset(&rc16, 0, sizeof(rc16));
    142     rc16 = asmfoo16();
    143     if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
    144     {
    145         printf("631main: asmfoo12 failed\n");
    146         rcRet++;
    147     }
    148 
     217    rc4 = asmfoosys4();
     218    if (rc4.au[0] != 1)
     219    {
     220        printf("631main: asmfoosys4 failed\n");
     221        rcRet++;
     222    }
     223
     224    memset(&rc8, 0, sizeof(rc8));
     225    rc8 = asmfoosys8();
     226    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     227    {
     228        printf("631main: asmfoosys8 failed\n");
     229        rcRet++;
     230    }
     231
     232    memset(&rc12, 0, sizeof(rc12));
     233    rc12 = asmfoosys12();
     234    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     235    {
     236        printf("631main: asmfoosys12 failed\n");
     237        rcRet++;
     238    }
     239
     240    memset(&rc16, 0, sizeof(rc16));
     241    rc16 = asmfoosys16();
     242    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     243    {
     244        printf("631main: asmfoosys12 failed\n");
     245        rcRet++;
     246    }
     247
     248
     249    /*
     250     * _Optlink
     251     */
     252    /* gcc */
     253    memset(&rc4, 0, sizeof(rc4));
     254    rc4 = fooopt4();
     255    if (rc4.au[0] != 1)
     256    {
     257        printf("631main: fooopt4 failed\n");
     258        rcRet++;
     259    }
     260
     261    memset(&rc8, 0, sizeof(rc8));
     262    rc8 = fooopt8();
     263    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     264    {
     265        printf("631main: fooopt8 failed\n");
     266        rcRet++;
     267    }
     268
     269    memset(&rc12, 0, sizeof(rc12));
     270    rc12 = fooopt12();
     271    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     272    {
     273        printf("631main: fooopt12 failed\n");
     274        rcRet++;
     275    }
     276
     277    memset(&rc16, 0, sizeof(rc16));
     278    rc16 = fooopt16();
     279    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     280    {
     281        printf("631main: fooopt12 failed\n");
     282        rcRet++;
     283    }
     284
     285    /* asm */
     286    memset(&rc4, 0, sizeof(rc4));
     287    rc4 = asmfooopt4();
     288    if (rc4.au[0] != 1)
     289    {
     290        printf("631main: asmfooopt4 failed\n");
     291        rcRet++;
     292    }
     293
     294    memset(&rc8, 0, sizeof(rc8));
     295    rc8 = asmfooopt8();
     296    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     297    {
     298        printf("631main: asmfooopt8 failed\n");
     299        rcRet++;
     300    }
     301
     302    memset(&rc12, 0, sizeof(rc12));
     303    rc12 = asmfooopt12();
     304    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     305    {
     306        printf("631main: asmfooopt12 failed\n");
     307        rcRet++;
     308    }
     309
     310    memset(&rc16, 0, sizeof(rc16));
     311    rc16 = asmfooopt16();
     312    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     313    {
     314        printf("631main: asmfooopt12 failed\n");
     315        rcRet++;
     316    }
     317
     318
     319    /*
     320     * __stdcall
     321     */
     322    /* gcc */
     323    memset(&rc4, 0, sizeof(rc4));
     324    rc4 = foostd4();
     325    if (rc4.au[0] != 1)
     326    {
     327        printf("631main: foostd4 failed\n");
     328        rcRet++;
     329    }
     330
     331    memset(&rc8, 0, sizeof(rc8));
     332    rc8 = foostd8();
     333    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     334    {
     335        printf("631main: foostd8 failed\n");
     336        rcRet++;
     337    }
     338
     339    memset(&rc12, 0, sizeof(rc12));
     340    rc12 = foostd12();
     341    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     342    {
     343        printf("631main: foostd12 failed\n");
     344        rcRet++;
     345    }
     346
     347    memset(&rc16, 0, sizeof(rc16));
     348    rc16 = foostd16();
     349    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     350    {
     351        printf("631main: foostd12 failed\n");
     352        rcRet++;
     353    }
     354
     355    /* asm */
     356    memset(&rc4, 0, sizeof(rc4));
     357    rc4 = asmfoostd4();
     358    if (rc4.au[0] != 1)
     359    {
     360        printf("631main: asmfoostd4 failed\n");
     361        rcRet++;
     362    }
     363
     364    memset(&rc8, 0, sizeof(rc8));
     365    rc8 = asmfoostd8();
     366    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     367    {
     368        printf("631main: asmfoostd8 failed\n");
     369        rcRet++;
     370    }
     371
     372    memset(&rc12, 0, sizeof(rc12));
     373    rc12 = asmfoostd12();
     374    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     375    {
     376        printf("631main: asmfoostd12 failed\n");
     377        rcRet++;
     378    }
     379
     380    memset(&rc16, 0, sizeof(rc16));
     381    rc16 = asmfoostd16();
     382    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     383    {
     384        printf("631main: asmfoostd12 failed\n");
     385        rcRet++;
     386    }
     387
     388
     389    /*
     390     * Default
     391     */
     392    /* gcc */
     393    memset(&rc4, 0, sizeof(rc4));
     394    rc4 = foodef4();
     395    if (rc4.au[0] != 1)
     396    {
     397        printf("631main: foodef4 failed\n");
     398        rcRet++;
     399    }
     400
     401    memset(&rc8, 0, sizeof(rc8));
     402    rc8 = foodef8();
     403    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     404    {
     405        printf("631main: foodef8 failed\n");
     406        rcRet++;
     407    }
     408
     409    memset(&rc12, 0, sizeof(rc12));
     410    rc12 = foodef12();
     411    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     412    {
     413        printf("631main: foodef12 failed\n");
     414        rcRet++;
     415    }
     416
     417    memset(&rc16, 0, sizeof(rc16));
     418    rc16 = foodef16();
     419    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     420    {
     421        printf("631main: foodef12 failed\n");
     422        rcRet++;
     423    }
     424
     425    /* asm */
     426    memset(&rc4, 0, sizeof(rc4));
     427    rc4 = DEF(asmfoodef4)();
     428    if (rc4.au[0] != 1)
     429    {
     430        printf("631main: asmfoodef4 failed\n");
     431        rcRet++;
     432    }
     433
     434    memset(&rc8, 0, sizeof(rc8));
     435    rc8 = DEF(asmfoodef8)();
     436    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     437    {
     438        printf("631main: asmfoodef8 failed\n");
     439        rcRet++;
     440    }
     441
     442    memset(&rc12, 0, sizeof(rc12));
     443    rc12 = DEF(asmfoodef12)();
     444    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     445    {
     446        printf("631main: asmfoodef12 failed\n");
     447        rcRet++;
     448    }
     449
     450    memset(&rc16, 0, sizeof(rc16));
     451    rc16 = DEF(asmfoodef16)();
     452    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     453    {
     454        printf("631main: asmfoodef12 failed\n");
     455        rcRet++;
     456    }
     457
     458
     459    /* results */
    149460    if (!rcRet)
    150461        printf("Successfully executed return struct testcase (#631).\n");
Note: See TracChangeset for help on using the changeset viewer.