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    foo8(void)
    5675{
    5776    struct ret8bytes ret = {1,2};
    … …  
    5978}
    6079
    61 struct ret12bytes _System   foo12(void)
     80struct ret12bytes _System   foo12(void)
    6281{
    6382    struct ret12bytes ret = {1,2,3};
    … …  
    6584}
    6685
    67 struct ret16bytes _System   foo16(void)
     86struct ret16bytes _System   foo16(void)
    6887{
    6988    struct ret16bytes ret = {1,2,3,4};
    7089    return ret;
    7190}
     91
     92
     93
     94
     95
     96
     97
     98
     99
     100
     101
     102
     103
     104
     105
     106
     107
     108
     109
     110
     111
     112
     113
     114
     115
     116
     117
     118
     119
     120
     121
     122
     123
     124
     125
     126
     127
     128
     129
     130
     131
     132
     133
     134
     135
     136
     137
     138
     139
     140
     141
     142
     143
     144
     145
     146
     147
     148
     149
     150
     151
     152
     153
     154
     155
     156
     157
     158
     159
     160
     161
     162
     163
     164
     165
     166
     167
     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 = foo4();
     185    if (rc4.au[0] != 1)
     186    {
     187        printf("631main: foo4 failed\n");
     188        rcRet++;
     189    }
     190
     191    memset(&rc8, 0, sizeof(rc8));
     192    rc8 = foo8();
     193    if (rc8.au[0] != 1 && rc8.au[1] != 2)
     194    {
     195        printf("631main: foo8 failed\n");
     196        rcRet++;
     197    }
     198
     199    memset(&rc12, 0, sizeof(rc12));
     200    rc12 = foo12();
     201    if (rc12.au[0] != 1 && rc12.au[1] != 2 && rc16.au[2] != 3)
     202    {
     203        printf("631main: foo12 failed\n");
     204        rcRet++;
     205    }
     206
     207    memset(&rc16, 0, sizeof(rc16));
     208    rc16 = foo16();
     209    if (rc16.au[0] != 1 && rc16.au[1] != 2 && rc16.au[2] != 3 && rc16.au[3] != 4)
     210    {
     211        printf("631main: foo12 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.