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; 107 struct ret16bytes __stdcall asmfoostd16(void)
     17        align 010h
     18
     19        public _asmfoostd16@0
     20_asmfoostd16@0  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; 110     return ret;
     25        mov     eax,[ebp+08h];  @CBE10
     26
     27; 109     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; 110     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; 109     struct ret16bytes ret = {1,2,3,4};
    3737        mov     dword ptr [ebp-08h],03h;        ret
    3838
    39 ; 60     return ret;
     39; 110     return ret;
    4040        mov     [eax+04h],edx
    4141        mov     edx,[ebp-08h];  ret
    4242
    43 ; 59     struct ret16bytes ret = {1,2,3,4};
     43; 109     struct ret16bytes ret = {1,2,3,4};
    4444        mov     dword ptr [ebp-04h],04h;        ret
    4545
    46 ; 60     return ret;
     46; 110     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     04h
     52_asmfoostd16@0  endp
     53
     54; 101 struct ret12bytes __stdcall asmfoostd12(void)
     55        align 010h
     56
     57        public _asmfoostd12@0
     58_asmfoostd12@0  proc
     59
     60; 104     return ret;
     61        mov     eax,[esp+04h];  @CBE9
     62
     63; 103     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; 104     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; 103     struct ret12bytes ret = {1,2,3};
    7373        mov     dword ptr [esp-04h],03h;        ret
    7474
    75 ; 54     return ret;
     75; 104     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; 40     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    asmfoosys8(void)
    4645{
    4746    struct ret8bytes ret = {1,2};
    … …  
    4948}
    5049
    51 struct ret12bytes _System   asmfoo12(void)
     50struct ret12bytes _System   asmfoosys12(void)
    5251{
    5352    struct ret12bytes ret = {1,2,3};
    … …  
    5554}
    5655
    57 struct ret16bytes _System   asmfoo16(void)
     56struct ret16bytes _System   asmfoosys16(void)
    5857{
    5958    struct ret16bytes ret = {1,2,3,4};
    … …  
    6160}
    6261
     62/* optlink */
     63struct ret4bytes _Optlink   asmfooopt4(void)
     64{
     65    struct ret4bytes ret = {1};
     66    return ret;
     67}
     68
     69struct ret8bytes _Optlink   asmfooopt8(void)
     70{
     71    struct ret8bytes ret = {1,2};
     72    return ret;
     73}
     74
     75struct ret12bytes _Optlink  asmfooopt12(void)
     76{
     77    struct ret12bytes ret = {1,2,3};
     78    return ret;
     79}
     80
     81struct ret16bytes _Optlink  asmfooopt16(void)
     82{
     83    struct ret16bytes ret = {1,2,3,4};
     84    return ret;
     85}
     86
     87
     88/* stdcall */
     89struct ret4bytes __stdcall  asmfoostd4(void)
     90{
     91    struct ret4bytes ret = {1};
     92    return ret;
     93}
     94
     95struct ret8bytes __stdcall  asmfoostd8(void)
     96{
     97    struct ret8bytes ret = {1,2};
     98    return ret;
     99}
     100
     101struct ret12bytes __stdcall asmfoostd12(void)
     102{
     103    struct ret12bytes ret = {1,2,3};
     104    return ret;
     105}
     106
     107struct ret16bytes __stdcall asmfoostd16(void)
     108{
     109    struct ret16bytes ret = {1,2,3,4};
     110    return ret;
     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    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.