Changeset 675


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

More stuff.

Location:
trunk/testcase
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/testcase/631asm.asm

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.2
    r674 r675  
    1414CODE32  segment
    1515
    16 ; 57 struct ret16bytes _System   asmfoo16(void)
    17         align 010h
    18 
    19         public asmfoo16
    20 asmfoo16        proc
     16; 16(void)
     17        align 010h
     18
     19        public
     20  proc
    2121        push    ebp
    2222        mov     ebp,esp
    2323
    24 ; 60     return ret;
    25         mov     eax,[ebp+08h];  @CBE4
    26 
    27 ; 59     struct ret16bytes ret = {1,2,3,4};
     24; 0     return ret;
     25        mov     eax,[ebp+08h];  @CBE
     26
     27; 9     struct ret16bytes ret = {1,2,3,4};
    2828        mov     dword ptr [ebp-010h],01h;       ret
    2929        mov     dword ptr [ebp-0ch],02h;        ret
    3030
    31 ; 60     return ret;
     31; 0     return ret;
    3232        mov     ecx,[ebp-010h]; ret
    3333        mov     edx,[ebp-0ch];  ret
    3434        mov     [eax],ecx
    3535
    36 ; 59     struct ret16bytes ret = {1,2,3,4};
     36; 9     struct ret16bytes ret = {1,2,3,4};
    3737        mov     dword ptr [ebp-08h],03h;        ret
    3838
    39 ; 60     return ret;
     39; 0     return ret;
    4040        mov     [eax+04h],edx
    4141        mov     edx,[ebp-08h];  ret
    4242
    43 ; 59     struct ret16bytes ret = {1,2,3,4};
     43; 9     struct ret16bytes ret = {1,2,3,4};
    4444        mov     dword ptr [ebp-04h],04h;        ret
    4545
    46 ; 60     return ret;
     46; 0     return ret;
    4747        mov     ecx,[ebp-04h];  ret
    4848        mov     [eax+08h],edx
    4949        mov     [eax+0ch],ecx
    5050        pop     ebp
    51         ret     
    52 asmfoo16        endp
    53 
    54 ; 51 struct ret12bytes _System   asmfoo12(void)
    55         align 010h
    56 
    57         public asmfoo12
    58 asmfoo12        proc
    59 
    60 ; 54     return ret;
    61         mov     eax,[esp+04h];  @CBE3
    62 
    63 ; 53     struct ret12bytes ret = {1,2,3};
     51        ret     
     52  endp
     53
     54; 12(void)
     55        align 010h
     56
     57        public
     58  proc
     59
     60; 4     return ret;
     61        mov     eax,[esp+04h];  @CBE
     62
     63; 3     struct ret12bytes ret = {1,2,3};
    6464        mov     dword ptr [esp-0ch],01h;        ret
    6565        mov     dword ptr [esp-08h],02h;        ret
    6666
    67 ; 54     return ret;
     67; 4     return ret;
    6868        mov     edx,[esp-0ch];  ret
    6969        mov     ecx,[esp-08h];  ret
    7070        mov     [eax],edx
    7171
    72 ; 53     struct ret12bytes ret = {1,2,3};
     72; 3     struct ret12bytes ret = {1,2,3};
    7373        mov     dword ptr [esp-04h],03h;        ret
    7474
    75 ; 54     return ret;
     75; 4     return ret;
    7676        mov     [eax+04h],ecx
    7777        mov     ecx,[esp-04h];  ret
    7878        mov     [eax+08h],ecx
    79         ret     
    80 asmfoo12        endp
    81 
    82 ; 45 struct ret8bytes _System    asmfoo8(void)
    83         align 010h
    84 
    85         public asmfoo8
    86 asmfoo8 proc
    87 
    88 ; 48     return ret;
    89         mov     eax,[esp+04h];  @CBE2
    90 
    91 ; 47     struct ret8bytes ret = {1,2};
     79        ret     04h
     80_asmfoostd12@0  endp
     81
     82; 95 struct ret8bytes __stdcall  asmfoostd8(void)
     83        align 010h
     84
     85        public _asmfoostd8@0
     86_asmfoostd8@0   proc
     87
     88; 97     struct ret8bytes ret = {1,2};
    9289        mov     dword ptr [esp-08h],01h;        ret
    9390        mov     dword ptr [esp-04h],02h;        ret
    9491
    95 ; 48     return ret;
     92; 98     return ret;
     93        mov     eax,[esp-08h];  ret
     94        mov     edx,[esp-04h];  ret
     95        ret     
     96_asmfoostd8@0   endp
     97
     98; 89 struct ret4bytes __stdcall  asmfoostd4(void)
     99        align 010h
     100
     101        public _asmfoostd4@0
     102_asmfoostd4@0   proc
     103
     104; 91     struct ret4bytes ret = {1};
     105        mov     dword ptr [esp-04h],01h;        ret
     106
     107; 92     return ret;
     108        mov     eax,[esp-04h];  ret
     109        ret     
     110_asmfoostd4@0   endp
     111
     112; 81 struct ret16bytes _Optlink  asmfooopt16(void)
     113        align 010h
     114
     115        public asmfooopt16
     116asmfooopt16     proc
     117        push    ebp
     118        mov     ebp,esp
     119
     120; 84     return ret;
     121        mov     eax,[ebp+08h];  @CBE8
     122
     123; 83     struct ret16bytes ret = {1,2,3,4};
     124        mov     dword ptr [ebp-010h],01h;       ret
     125        mov     dword ptr [ebp-0ch],02h;        ret
     126
     127; 84     return ret;
     128        mov     ecx,[ebp-010h]; ret
     129        mov     edx,[ebp-0ch];  ret
     130        mov     [eax],ecx
     131
     132; 83     struct ret16bytes ret = {1,2,3,4};
     133        mov     dword ptr [ebp-08h],03h;        ret
     134
     135; 84     return ret;
     136        mov     [eax+04h],edx
     137        mov     edx,[ebp-08h];  ret
     138
     139; 83     struct ret16bytes ret = {1,2,3,4};
     140        mov     dword ptr [ebp-04h],04h;        ret
     141
     142; 84     return ret;
     143        mov     ecx,[ebp-04h];  ret
     144        mov     [eax+08h],edx
     145        mov     [eax+0ch],ecx
     146        pop     ebp
     147        ret     
     148asmfooopt16     endp
     149
     150; 75 struct ret12bytes _Optlink  asmfooopt12(void)
     151        align 010h
     152
     153        public asmfooopt12
     154asmfooopt12     proc
     155
     156; 78     return ret;
     157        mov     eax,[esp+04h];  @CBE7
     158
     159; 77     struct ret12bytes ret = {1,2,3};
     160        mov     dword ptr [esp-0ch],01h;        ret
     161        mov     dword ptr [esp-08h],02h;        ret
     162
     163; 78     return ret;
     164        mov     edx,[esp-0ch];  ret
     165        mov     ecx,[esp-08h];  ret
     166        mov     [eax],edx
     167
     168; 77     struct ret12bytes ret = {1,2,3};
     169        mov     dword ptr [esp-04h],03h;        ret
     170
     171; 78     return ret;
     172        mov     [eax+04h],ecx
     173        mov     ecx,[esp-04h];  ret
     174        mov     [eax+08h],ecx
     175        ret     
     176asmfooopt12     endp
     177
     178; 69 struct ret8bytes _Optlink   asmfooopt8(void)
     179        align 010h
     180
     181        public asmfooopt8
     182asmfooopt8      proc
     183
     184; 72     return ret;
     185        mov     eax,[esp+04h];  @CBE6
     186
     187; 71     struct ret8bytes ret = {1,2};
     188        mov     dword ptr [esp-08h],01h;        ret
     189        mov     dword ptr [esp-04h],02h;        ret
     190
     191; 72     return ret;
    96192        mov     edx,[esp-08h];  ret
    97193        mov     ecx,[esp-04h];  ret
    … …  
    99195        mov     [eax+04h],ecx
    100196        ret     
    101 asmfoo8 endp
    102 
    103 ; 39 struct ret4bytes _System    asmfoo4(void)
    104         align 010h
    105 
    106         public asmfoo4
    107 asmfoo4 proc
    108 
    109 ; 42     return ret;
     197asmfooopt8      endp
     198
     199; 63 struct ret4bytes _Optlink   asmfooopt4(void)
     200        align 010h
     201
     202        public asmfooopt4
     203asmfooopt4      proc
     204
     205; 66     return ret;
     206        mov     eax,[esp+04h];  @CBE5
     207
     208; 65     struct ret4bytes ret = {1};
     209        mov     dword ptr [esp-04h],01h;        ret
     210
     211; 66     return ret;
     212        mov     ecx,[esp-04h];  ret
     213        mov     [eax],ecx
     214        ret     
     215asmfooopt4      endp
     216
     217; 56 struct ret16bytes _System   asmfoosys16(void)
     218        align 010h
     219
     220        public asmfoosys16
     221asmfoosys16     proc
     222        push    ebp
     223        mov     ebp,esp
     224
     225; 59     return ret;
     226        mov     eax,[ebp+08h];  @CBE4
     227
     228; 58     struct ret16bytes ret = {1,2,3,4};
     229        mov     dword ptr [ebp-010h],01h;       ret
     230        mov     dword ptr [ebp-0ch],02h;        ret
     231
     232; 59     return ret;
     233        mov     ecx,[ebp-010h]; ret
     234        mov     edx,[ebp-0ch];  ret
     235        mov     [eax],ecx
     236
     237; 58     struct ret16bytes ret = {1,2,3,4};
     238        mov     dword ptr [ebp-08h],03h;        ret
     239
     240; 59     return ret;
     241        mov     [eax+04h],edx
     242        mov     edx,[ebp-08h];  ret
     243
     244; 58     struct ret16bytes ret = {1,2,3,4};
     245        mov     dword ptr [ebp-04h],04h;        ret
     246
     247; 59     return ret;
     248        mov     ecx,[ebp-04h];  ret
     249        mov     [eax+08h],edx
     250        mov     [eax+0ch],ecx
     251        pop     ebp
     252        ret     
     253asmfoosys16     endp
     254
     255; 50 struct ret12bytes _System   asmfoosys12(void)
     256        align 010h
     257
     258        public asmfoosys12
     259asmfoosys12     proc
     260
     261; 53     return ret;
     262        mov     eax,[esp+04h];  @CBE3
     263
     264; 52     struct ret12bytes ret = {1,2,3};
     265        mov     dword ptr [esp-0ch],01h;        ret
     266        mov     dword ptr [esp-08h],02h;        ret
     267
     268; 53     return ret;
     269        mov     edx,[esp-0ch];  ret
     270        mov     ecx,[esp-08h];  ret
     271        mov     [eax],edx
     272
     273; 52     struct ret12bytes ret = {1,2,3};
     274        mov     dword ptr [esp-04h],03h;        ret
     275
     276; 53     return ret;
     277        mov     [eax+04h],ecx
     278        mov     ecx,[esp-04h];  ret
     279        mov     [eax+08h],ecx
     280        ret     
     281asmfoosys12     endp
     282
     283; 44 struct ret8bytes _System    asmfoosys8(void)
     284        align 010h
     285
     286        public asmfoosys8
     287asmfoosys8      proc
     288
     289; 47     return ret;
     290        mov     eax,[esp+04h];  @CBE2
     291
     292; 46     struct ret8bytes ret = {1,2};
     293        mov     dword ptr [esp-08h],01h;        ret
     294        mov     dword ptr [esp-04h],02h;        ret
     295
     296; 47     return ret;
     297        mov     edx,[esp-08h];  ret
     298        mov     ecx,[esp-04h];  ret
     299        mov     [eax],edx
     300        mov     [eax+04h],ecx
     301        ret     
     302asmfoosys8      endp
     303
     304; 38 struct ret4bytes _System    asmfoosys4(void)
     305        align 010h
     306
     307        public asmfoosys4
     308asmfoosys4      proc
     309
     310; 41     return ret;
    110311        mov     eax,[esp+04h];  @CBE1
    111312
    112 ; 41     struct ret4bytes ret = {1};
     313; 4     struct ret4bytes ret = {1};
    113314        mov     dword ptr [esp-04h],01h;        ret
    114315
    115 ; 42     return ret;
    116         mov     ecx,[esp-04h];  ret
    117         mov     [eax],ecx
    118         ret     
    119 asmfoo4 endp
     316; 41     return ret;
     317        mov     ecx,[esp-04h];  ret
     318        mov     [eax],ecx
     319        ret     
     320asmfoosys4      endp
     321
     322
     323
     324
     325public _asmfoodef4_gcc
     326_asmfoodef4_gcc:
     327        mov         eax, 1
     328        ret
     329   
     330public _asmfoodef8_gcc
     331_asmfoodef8_gcc:
     332        mov         eax, 1
     333        mov         edx, 2
     334        ret
     335   
     336public _asmfoodef12_gcc
     337_asmfoodef12_gcc:
     338        push    ebp
     339        mov     ebp, esp
     340        sub     esp, 24
     341        mov     eax, [ebp + 8]
     342        mov     dword ptr [eax + 0], 1
     343        mov     dword ptr [eax + 4], 2
     344        mov     dword ptr [eax + 8], 3
     345        leave
     346        ret     4
     347   
     348public _asmfoodef16_gcc
     349_asmfoodef16_gcc:
     350        push    ebp
     351        mov     ebp, esp
     352        sub     esp, 24
     353        mov     eax, [ebp + 8]
     354        mov     dword ptr [eax + 0], 1
     355        mov     dword ptr [eax + 4], 2
     356        mov     dword ptr [eax + 8], 3
     357        mov     dword ptr [eax +12], 4
     358        leave
     359        ret     4
     360
    120361CODE32  ends
    121362end

  • trunk/testcase/631asmc.c

    • Property cvs2svn:cvs-rev changed from 1.1 to 1.2
    r674 r675  
    3636 
    3737
    38 
    39 struct ret4bytes _System    asmfoo4(void)
     38struct ret4bytes _System    asmfoosys4(void)
    4039{
    4140    struct ret4bytes ret = {1};
    … …  
    4342}
    4443
    45 struct ret8bytes _System    asmfoo8(void)
     44struct ret8bytes _System    asmfoo8(void)
    4645{
    4746    struct ret8bytes ret = {1,2};
    … …  
    4948}
    5049
    51 struct ret12bytes _System   asmfoo12(void)
     50struct ret12bytes _System   asmfoo12(void)
    5251{
    5352    struct ret12bytes ret = {1,2,3};
    … …  
    5554}
    5655
    57 struct ret16bytes _System   asmfoo16(void)
     56struct ret16bytes _System   asmfoo16(void)
    5857{
    5958    struct ret16bytes ret = {1,2,3,4};
    … …  
    6160}
    6261
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
     100
     101
     102
     103
     104
     105
     106
     107
     108
     109
     110
     111
     112

  • 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.