source: branches/libc-0.6/testcase/631main.c

Last change on this file was 675, checked in by bird, 22 years ago

More stuff.
  • Property cvs2svn:cvs-rev set to 1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
File size: 10.1 KB
Line 
1/* $Id: 631main.c 675 2003-09-09 18:27:08Z bird $
2 *
3 * Testcase #631 - return structs from _System and _Optlink.
4 *
5 * InnoTek Systemberatung GmbH confidential
6 *
7 * Copyright (c) 2003 InnoTek Systemberatung GmbH
8 * Author: knut st. osmundsen <bird-srcspam@anduin.net>
9 *
10 * All Rights Reserved
11 *
12 */
13
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
22
23
24/*******************************************************************************
25* Structures and Typedefs *
26*******************************************************************************/
27struct ret4bytes
28{
29 unsigned int au[1];
30};
31
32struct ret8bytes
33{
34 unsigned int au[2];
35};
36
37struct ret12bytes
38{
39 unsigned int au[3];
40};
41
42struct ret16bytes
43{
44 unsigned int au[4];
45};
46
47
48/*******************************************************************************
49* External Functions *
50*******************************************************************************/
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)
69{
70 struct ret4bytes ret = {1};
71 return ret;
72}
73
74struct ret8bytes _System foosys8(void)
75{
76 struct ret8bytes ret = {1,2};
77 return ret;
78}
79
80struct ret12bytes _System foosys12(void)
81{
82 struct ret12bytes ret = {1,2,3};
83 return ret;
84}
85
86struct ret16bytes _System foosys16(void)
87{
88 struct ret16bytes ret = {1,2,3,4};
89 return ret;
90}
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
171
172
173int main(void)
174{
175 int rcRet = 0;
176 struct ret4bytes rc4;
177 struct ret8bytes rc8;
178 struct ret12bytes rc12;
179 struct ret16bytes rc16;
180
181
182 /* gcc */
183 memset(&rc4, 0, sizeof(rc4));
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");
212 rcRet++;
213 }
214
215 /* asm */
216 memset(&rc4, 0, sizeof(rc4));
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 */
460 if (!rcRet)
461 printf("Successfully executed return struct testcase (#631).\n");
462 else
463 printf("631main: %d failures.\n", rcRet);
464 return rcRet;
465}
466
Note: See TracBrowser for help on using the repository browser.