]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/testsuite/gdb.base/call-ar-st.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
This commit was manufactured by cvs2svn to create branch
[thirdparty/binutils-gdb.git] / gdb / testsuite / gdb.base / call-ar-st.c
CommitLineData
c906108c
SS		 1
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5
6/**************************************************************************
7 * TESTS :
8 * -- function arguments that are enumerated types
9 * -- small structure arguments ( <= 64 bits )
10 * -- stored in registers
11 * -- stored on the stack
12 * -- large structure arguments ( > 64 bits )
13 * -- stored in registers
14 * -- stored on the stack
15 * -- array arguments
16 * -- caller is a leaf routine :
17 * -- use the call command from within an init routine (i.e.
18 * init_bit_flags, init_bit_flags_combo, init_array_rep)
19 * -- caller doesn't have enough space for all the function arguments :
20 * -- call print_long_arg_list from inside print_small_structs
21 ***************************************************************************/
22
23/* Some enumerated types -- used to test that the structureal data type is
24 * retrieved for function arguments with typedef data types.
25 */
26typedef int id_int;
27
28typedef enum {
29 BLACK,
30 BLUE,
31 BROWN,
32 ECRUE,
33 GOLD,
34 GRAY,
35 GREEN,
36 IVORY,
37 MAUVE,
38 ORANGE,
39 PINK,
40 PURPLE,
41 RED,
42 SILVER,
43 TAN,
44 VIOLET,
45 WHITE,
46 YELLOW} colors;
47
48/* A large structure (> 64 bits) used to test passing large structures as
49 * parameters
50 */
51
52struct array_rep_info_t {
53 int next_index[10];
54 int values[10];
55 int head;
56};
57
58/*****************************************************************************
59 * Small structures ( <= 64 bits). These are used to test passing small
60 * structures as parameters and test argument size promotion.
61 *****************************************************************************/
62
63 /* 64 bits
64 */
65struct small_rep_info_t {
66 int value;
67 int head;
68};
69
70/* 6 bits : really fits in 8 bits and is promoted to 32 bits
71 */
72struct bit_flags_t {
73 unsigned alpha :1;
74 unsigned beta :1;
75 unsigned gamma :1;
76 unsigned delta :1;
77 unsigned epsilon :1;
78 unsigned omega :1;
79};
80
81/* 22 bits : really fits in 40 bits and is promoted to 64 bits
82 */
83struct bit_flags_combo_t {
84 unsigned alpha :1;
85 unsigned beta :1;
86 char ch1;
87 unsigned gamma :1;
88 unsigned delta :1;
89 char ch2;
90 unsigned epsilon :1;
91 unsigned omega :1;
92};
93
94/* 64 bits
95 */
96struct one_double_t {
97 double double1;
98};
99
100/* 64 bits
101 */
102struct two_floats_t {
103 float float1;
104 float float2;
105};
106
107/* 16 bits : promoted to 32 bits
108 */
109struct two_char_t {
110 char ch1;
111 char ch2;
112};
113
114/* 24 bits : promoted to 32 bits
115 */
116struct three_char_t {
117 char ch1;
118 char ch2;
119 char ch3;
120};
121
122/* 40 bits : promoted to 64 bits
123 */
124struct five_char_t {
125 char ch1;
126 char ch2;
127 char ch3;
128 char ch4;
129 char ch5;
130};
131
132/* 40 bits : promoted to 64 bits
133 */
134struct int_char_combo_t {
135 int int1;
136 char ch1;
137};
138
139/*****************************************************************
140 * PRINT_STUDENT_ID_SHIRT_COLOR :
141 * IN id_int student -- enumerated type
142 * IN colors shirt -- enumerated type
143 *****************************************************************/
085dd6e6
JM		 144#ifdef PROTOTYPES
145void print_student_id_shirt_color (id_int student, colors shirt)
146#else
c906108c
SS		 147void print_student_id_shirt_color ( student, shirt )
148 id_int student;
149 colors shirt;
085dd6e6 150#endif
c906108c
SS		 151{
152
153 printf("student id : %d\t", student);
154 printf("shirt color : ");
155 switch (shirt) {
156 case BLACK : printf("BLACK\n");
157 break;
158 case BLUE : printf("BLUE\n");
159 break;
160 case BROWN : printf("BROWN\n");
161 break;
162 case ECRUE : printf("ECRUE\n");
163 break;
164 case GOLD : printf("GOLD\n");
165 break;
166 case GRAY : printf("GRAY\n");
167 break;
168 case GREEN : printf("GREEN\n");
169 break;
170 case IVORY : printf("IVORY\n");
171 break;
172 case MAUVE : printf("MAUVE\n");
173 break;
174 case ORANGE : printf("ORANGE\n");
175 break;
176 case PINK : printf("PINK\n");
177 break;
178 case PURPLE : printf("PURPLE\n");
179 break;
180 case RED : printf("RED\n");
181 break;
182 case SILVER : printf("SILVER\n");
183 break;
184 case TAN : printf("TAN\n");
185 break;
186 case VIOLET : printf("VIOLET\n");
187 break;
188 case WHITE : printf("WHITE\n");
189 break;
190 case YELLOW : printf("YELLOW\n");
191 break;
192 }
193}
194
195/*****************************************************************
196 * PRINT_CHAR_ARRAY :
197 * IN char array_c[] -- character array
198 *****************************************************************/
085dd6e6
JM		 199#ifdef PROTOTYPES
200void print_char_array (char array_c[])
201#else
c906108c
SS		 202void print_char_array ( array_c )
203 char array_c[];
085dd6e6 204#endif
c906108c
SS		 205{
206
207 int index;
208
209 printf("array_c :\n");
210 printf("=========\n\n");
211 for (index = 0; index < 120; index++) {
212 printf("%1c", array_c[index]);
213 if ((index%50) == 0) printf("\n");
214 }
215 printf("\n\n");
216}
217
218/*****************************************************************
219 * PRINT_DOUBLE_ARRAY :
220 * IN double array_d[] -- array of doubles
221 *****************************************************************/
085dd6e6
JM		 222#ifdef PROTOTYPES
223void print_double_array (double array_d[])
224#else
c906108c
SS		 225void print_double_array (array_d)
226 double array_d[];
085dd6e6 227#endif
c906108c
SS		 228{
229
230 int index;
231
232 printf("array_d :\n");
233 printf("=========\n\n");
1b7c05e7 234 for (index = 0; index < 9; index++) {
c906108c
SS		 235 printf("%f ", array_d[index]);
236 if ((index%8) == 0) printf("\n");
237 }
238 printf("\n\n");
239}
240
241/*****************************************************************
242 * PRINT_FLOAT_ARRAY:
243 * IN float array_f[] -- array of floats
244 *****************************************************************/
085dd6e6
JM		 245#ifdef PROTOTYPES
246void print_float_array (float array_f[])
247#else
c906108c
SS		 248void print_float_array ( array_f )
249 float array_f[];
085dd6e6 250#endif
c906108c
SS		 251{
252
253 int index;
254
255 printf("array_f :\n");
256 printf("=========\n\n");
257 for (index = 0; index < 15; index++) {
258 printf("%f ", array_f[index]);
259 if ((index%8) == 0) printf("\n");
260
261 }
262 printf("\n\n");
263}
264
265/*****************************************************************
266 * PRINT_INT_ARRAY:
267 * IN int array_i[] -- array of integers
268 *****************************************************************/
085dd6e6
JM		 269#ifdef PROTOTYPES
270void print_int_array (int array_i[])
271#else
c906108c
SS		 272void print_int_array ( array_i )
273 int array_i[];
085dd6e6 274#endif
c906108c
SS		 275{
276
277 int index;
278
279 printf("array_i :\n");
280 printf("=========\n\n");
281 for (index = 0; index < 50; index++) {
282 printf("%d ", array_i[index]);
283 if ((index%8) == 0) printf("\n");
284 }
285 printf("\n\n");
286
287}
288
289/*****************************************************************
290 * PRINT_ALL_ARRAYS:
291 * IN int array_i[] -- array of integers
292 * IN char array_c[] -- array of characters
293 * IN float array_f[] -- array of floats
294 * IN double array_d[] -- array of doubles
295 *****************************************************************/
085dd6e6
JM		 296#ifdef PROTOTYPES
297void print_all_arrays(int array_i[], char array_c[], float array_f[], double array_d[])
298#else
c906108c
SS		 299void print_all_arrays( array_i, array_c, array_f, array_d )
300 int array_i[];
301 char array_c[];
302 float array_f[];
303 double array_d[];
085dd6e6 304#endif
c906108c
SS		 305{
306 print_int_array(array_i);
307 print_char_array(array_c);
308 print_float_array(array_f);
309 print_double_array(array_d);
310}
311
312/*****************************************************************
313 * LOOP_COUNT :
314 * A do nothing function. Used to provide a point at which calls can be made.
315 *****************************************************************/
316void loop_count () {
317
318 int index;
319
320 for (index=0; index<4; index++);
321}
322
323/*****************************************************************
324 * COMPUTE_WITH_SMALL_STRUCTS :
325 * A do nothing function. Used to provide a point at which calls can be made.
326 * IN int seed
327 *****************************************************************/
085dd6e6
JM		 328#ifdef PROTOTYPES
329void compute_with_small_structs (int seed)
330#else
c906108c
SS		 331void compute_with_small_structs ( seed )
332 int seed;
085dd6e6 333#endif
c906108c
SS		 334{
335
336 struct small_rep_info_t array[4];
337 int index;
338
339 for (index = 0; index < 4; index++) {
340 array[index].value = index*seed;
341 array[index].head = (index+1)*seed;
342 }
343
344 for (index = 1; index < 4; index++) {
345 array[index].value = array[index].value + array[index-1].value;
346 array[index].head = array[index].head + array[index-1].head;
347 }
348}
349
350/*****************************************************************
351 * INIT_BIT_FLAGS :
352 * Initializes a bit_flags_t structure. Can call this function see
353 * the call command behavior when integer arguments do not fit into
354 * registers and must be placed on the stack.
355 * OUT struct bit_flags_t *bit_flags -- structure to be filled
356 * IN unsigned a -- 0 or 1
357 * IN unsigned b -- 0 or 1
358 * IN unsigned g -- 0 or 1
359 * IN unsigned d -- 0 or 1
360 * IN unsigned e -- 0 or 1
361 * IN unsigned o -- 0 or 1
362 *****************************************************************/
085dd6e6
JM		 363#ifdef PROTOTYPES
364void init_bit_flags (struct bit_flags_t *bit_flags, unsigned a, unsigned b, unsigned g, unsigned d, unsigned e, unsigned o)
365#else
c906108c
SS		 366void init_bit_flags ( bit_flags, a, b, g, d, e, o )
367struct bit_flags_t *bit_flags;
368unsigned a;
369unsigned b;
370unsigned g;
371unsigned d;
372unsigned e;
373unsigned o;
085dd6e6 374#endif
c906108c
SS		 375{
376
377 bit_flags->alpha = a;
378 bit_flags->beta = b;
379 bit_flags->gamma = g;
380 bit_flags->delta = d;
381 bit_flags->epsilon = e;
382 bit_flags->omega = o;
383}
384
385/*****************************************************************
386 * INIT_BIT_FLAGS_COMBO :
387 * Initializes a bit_flags_combo_t structure. Can call this function
388 * to see the call command behavior when integer and character arguments
389 * do not fit into registers and must be placed on the stack.
390 * OUT struct bit_flags_combo_t *bit_flags_combo -- structure to fill
391 * IN unsigned a -- 0 or 1
392 * IN unsigned b -- 0 or 1
393 * IN char ch1
394 * IN unsigned g -- 0 or 1
395 * IN unsigned d -- 0 or 1
396 * IN char ch2
397 * IN unsigned e -- 0 or 1
398 * IN unsigned o -- 0 or 1
399 *****************************************************************/
085dd6e6
JM		 400#ifdef PROTOTYPES
401void init_bit_flags_combo (struct bit_flags_combo_t *bit_flags_combo, unsigned a, unsigned b, char ch1, unsigned g, unsigned d, char ch2, unsigned e, unsigned o)
402#else
c906108c
SS		 403void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o )
404 struct bit_flags_combo_t *bit_flags_combo;
405 unsigned a;
406 unsigned b;
407 char ch1;
408 unsigned g;
409 unsigned d;
410 char ch2;
411 unsigned e;
412 unsigned o;
085dd6e6 413#endif
c906108c
SS		 414{
415
416 bit_flags_combo->alpha = a;
417 bit_flags_combo->beta = b;
418 bit_flags_combo->ch1 = ch1;
419 bit_flags_combo->gamma = g;
420 bit_flags_combo->delta = d;
421 bit_flags_combo->ch2 = ch2;
422 bit_flags_combo->epsilon = e;
423 bit_flags_combo->omega = o;
424}
425
426
427/*****************************************************************
428 * INIT_ONE_DOUBLE :
429 * OUT struct one_double_t *one_double -- structure to fill
430 * IN double init_val
431 *****************************************************************/
085dd6e6
JM		 432#ifdef PROTOTYPES
433void init_one_double (struct one_double_t *one_double, double init_val)
434#else
c906108c
SS		 435void init_one_double ( one_double, init_val )
436 struct one_double_t *one_double;
437 double init_val;
085dd6e6 438#endif
c906108c
SS		 439{
440
441 one_double->double1 = init_val;
442}
443
444/*****************************************************************
445 * INIT_TWO_FLOATS :
446 * OUT struct two_floats_t *two_floats -- structure to be filled
447 * IN float init_val1
448 * IN float init_val2
449 *****************************************************************/
085dd6e6
JM		 450#ifdef PROTOTYPES
451void init_two_floats (struct two_floats_t *two_floats, float init_val1, float init_val2)
452#else
c906108c
SS		 453void init_two_floats ( two_floats, init_val1, init_val2 )
454 struct two_floats_t *two_floats;
455 float init_val1;
456 float init_val2;
085dd6e6 457#endif
c906108c
SS		 458{
459 two_floats->float1 = init_val1;
460 two_floats->float2 = init_val2;
461}
462
463/*****************************************************************
464 * INIT_TWO_CHARS :
465 * OUT struct two_char_t *two_char -- structure to be filled
466 * IN char init_val1
467 * IN char init_val2
468 *****************************************************************/
085dd6e6
JM		 469#ifdef PROTOTYPES
470void init_two_chars (struct two_char_t *two_char, char init_val1, char init_val2)
471#else
c906108c
SS		 472void init_two_chars ( two_char, init_val1, init_val2 )
473 struct two_char_t *two_char;
474 char init_val1;
475 char init_val2;
085dd6e6 476#endif
c906108c
SS		 477{
478
479 two_char->ch1 = init_val1;
480 two_char->ch2 = init_val2;
481}
482
483/*****************************************************************
484 * INIT_THREE_CHARS :
485 * OUT struct three_char_t *three_char -- structure to be filled
486 * IN char init_val1
487 * IN char init_val2
488 * IN char init_val3
489 *****************************************************************/
085dd6e6
JM		 490#ifdef PROTOTYPES
491void init_three_chars (struct three_char_t *three_char, char init_val1, char init_val2, char init_val3)
492#else
c906108c
SS		 493void init_three_chars ( three_char, init_val1, init_val2, init_val3 )
494 struct three_char_t *three_char;
495 char init_val1;
496 char init_val2;
497 char init_val3;
085dd6e6 498#endif
c906108c
SS		 499{
500
501 three_char->ch1 = init_val1;
502 three_char->ch2 = init_val2;
503 three_char->ch3 = init_val3;
504}
505
506/*****************************************************************
507 * INIT_FIVE_CHARS :
508 * OUT struct five_char_t *five_char -- structure to be filled
509 * IN char init_val1
510 * IN char init_val2
511 * IN char init_val3
512 * IN char init_val4
513 * IN char init_val5
514 *****************************************************************/
085dd6e6
JM		 515#ifdef PROTOTYPES
516void init_five_chars (struct five_char_t *five_char, char init_val1, char init_val2, char init_val3, char init_val4, char init_val5)
517#else
c906108c
SS		 518void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init_val5 )
519 struct five_char_t *five_char;
520 char init_val1;
521 char init_val2;
522 char init_val3;
523 char init_val4;
524 char init_val5;
085dd6e6 525#endif
c906108c
SS		 526{
527 five_char->ch1 = init_val1;
528 five_char->ch2 = init_val2;
529 five_char->ch3 = init_val3;
530 five_char->ch4 = init_val4;
531 five_char->ch5 = init_val5;
532}
533
534/*****************************************************************
535 * INIT_INT_CHAR_COMBO :
536 * OUT struct int_char_combo_t *combo -- structure to be filled
537 * IN int init_val1
538 * IN char init_val2
539 *****************************************************************/
085dd6e6
JM		 540#ifdef PROTOTYPES
541void init_int_char_combo (struct int_char_combo_t *combo, int init_val1, char init_val2)
542#else
c906108c
SS		 543void init_int_char_combo ( combo, init_val1, init_val2 )
544 struct int_char_combo_t *combo;
545 int init_val1;
546 char init_val2;
085dd6e6 547#endif
c906108c
SS		 548{
549
550 combo->int1 = init_val1;
551 combo->ch1 = init_val2;
552}
553
554/*****************************************************************
555 * INIT_STRUCT_REP :
556 * OUT struct small_rep_into_t *small_struct -- structure to be filled
557 * IN int seed
558 *****************************************************************/
085dd6e6
JM		 559#ifdef PROTOTYPES
560void init_struct_rep(struct small_rep_info_t *small_struct, int seed)
561#else
c906108c
SS		 562void init_struct_rep( small_struct, seed )
563 struct small_rep_info_t *small_struct;
564 int seed;
085dd6e6 565#endif
c906108c
SS		 566{
567
568 small_struct->value = 2 + (seed*2);
569 small_struct->head = 0;
570}
571
572/*****************************************************************
573 * INIT_SMALL_STRUCTS :
574 * Takes all the small structures as input and calls the appropriate
575 * initialization routine for each structure
576 *****************************************************************/
085dd6e6
JM		 577#ifdef PROTOTYPES
578void init_small_structs (
579 struct small_rep_info_t *struct1,
580 struct small_rep_info_t *struct2,
581 struct small_rep_info_t *struct3,
582 struct small_rep_info_t *struct4,
583 struct bit_flags_t *flags,
584 struct bit_flags_combo_t *flags_combo,
585 struct three_char_t *three_char,
586 struct five_char_t *five_char,
587 struct int_char_combo_t *int_char_combo,
588 struct one_double_t *d1,
589 struct one_double_t *d2,
590 struct one_double_t *d3,
591 struct two_floats_t *f1,
592 struct two_floats_t *f2,
593 struct two_floats_t *f3)
594#else
c906108c
SS		 595void init_small_structs (struct1, struct2, struct3,struct4,flags,flags_combo,
596three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3)
597 struct small_rep_info_t *struct1;
598 struct small_rep_info_t *struct2;
599 struct small_rep_info_t *struct3;
600 struct small_rep_info_t *struct4;
601 struct bit_flags_t *flags;
602 struct bit_flags_combo_t *flags_combo;
603 struct three_char_t *three_char;
604 struct five_char_t *five_char;
605 struct int_char_combo_t *int_char_combo;
606 struct one_double_t *d1;
607 struct one_double_t *d2;
608 struct one_double_t *d3;
609 struct two_floats_t *f1;
610 struct two_floats_t *f2;
611 struct two_floats_t *f3;
085dd6e6 612#endif
c906108c
SS		 613{
614
615 init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1,
616 (unsigned)0, (unsigned)1, (unsigned)0 );
617 init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y',
618 (unsigned)1, (unsigned)0, 'n',
619 (unsigned)1, (unsigned)0 );
620 init_three_chars(three_char, 'a', 'b', 'c');
621 init_five_chars(five_char, 'l', 'm', 'n', 'o', 'p');
622 init_int_char_combo(int_char_combo, 123, 'z');
623 init_struct_rep(struct1, 2);
624 init_struct_rep(struct2, 4);
625 init_struct_rep(struct3, 5);
626 init_struct_rep(struct4, 6);
627 init_one_double ( d1, 10.5);
591b8fa3
PDM		 628 init_one_double ( d2, -3.375);
629 init_one_double ( d3, 675.09375);
c906108c
SS		 630 init_two_floats ( f1, 45.234, 43.6);
631 init_two_floats ( f2, 78.01, 122.10);
632 init_two_floats ( f3, -1232.345, -199.21);
633}
634
635/*****************************************************************
636 * PRINT_TEN_DOUBLES :
637 * ?????????????????????????????
638 ****************************************************************/
085dd6e6
JM		 639#ifdef PROTOTYPES
640void print_ten_doubles (
641 double d1,
642 double d2,
643 double d3,
644 double d4,
645 double d5,
646 double d6,
647 double d7,
648 double d8,
649 double d9,
650 double d10)
651#else
c906108c
SS		 652void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 )
653 double d1;
654 double d2;
655 double d3;
656 double d4;
657 double d5;
658 double d6;
659 double d7;
660 double d8;
661 double d9;
662 double d10;
085dd6e6 663#endif
c906108c
SS		 664{
665
666 printf("Two Doubles : %f\t%f\n", d1, d2);
667 printf("Two Doubles : %f\t%f\n", d3, d4);
668 printf("Two Doubles : %f\t%f\n", d5, d6);
669 printf("Two Doubles : %f\t%f\n", d7, d8);
670 printf("Two Doubles : %f\t%f\n", d9, d10);
671}
672
673/*****************************************************************
674 * PRINT_BIT_FLAGS :
675 * IN struct bit_flags_t bit_flags
676 ****************************************************************/
085dd6e6
JM		 677#ifdef PROTOTYPES
678void print_bit_flags (struct bit_flags_t bit_flags)
679#else
c906108c
SS		 680void print_bit_flags ( bit_flags )
681struct bit_flags_t bit_flags;
085dd6e6 682#endif
c906108c
SS		 683{
684
685 if (bit_flags.alpha) printf("alpha\n");
686 if (bit_flags.beta) printf("beta\n");
687 if (bit_flags.gamma) printf("gamma\n");
688 if (bit_flags.delta) printf("delta\n");
689 if (bit_flags.epsilon) printf("epsilon\n");
690 if (bit_flags.omega) printf("omega\n");
691}
692
693/*****************************************************************
694 * PRINT_BIT_FLAGS_COMBO :
695 * IN struct bit_flags_combo_t bit_flags_combo
696 ****************************************************************/
085dd6e6
JM		 697#ifdef PROTOTYPES
698void print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
699#else
c906108c 700void print_bit_flags_combo ( bit_flags_combo )
085dd6e6
JM		 701 struct bit_flags_combo_t bit_flags_combo;
702#endif
c906108c
SS		 703{
704
705 if (bit_flags_combo.alpha) printf("alpha\n");
706 if (bit_flags_combo.beta) printf("beta\n");
707 if (bit_flags_combo.gamma) printf("gamma\n");
708 if (bit_flags_combo.delta) printf("delta\n");
709 if (bit_flags_combo.epsilon) printf("epsilon\n");
710 if (bit_flags_combo.omega) printf("omega\n");
711 printf("ch1: %c\tch2: %c\n", bit_flags_combo.ch1, bit_flags_combo.ch2);
712}
713
714/*****************************************************************
715 * PRINT_ONE_DOUBLE :
716 * IN struct one_double_t one_double
717 ****************************************************************/
085dd6e6
JM		 718#ifdef PROTOTYPES
719void print_one_double (struct one_double_t one_double)
720#else
c906108c
SS		 721void print_one_double ( one_double )
722struct one_double_t one_double;
085dd6e6 723#endif
c906108c
SS		 724{
725
726 printf("Contents of one_double_t: \n\n");
727 printf("%f\n", one_double.double1);
728}
729
730/*****************************************************************
731 * PRINT_TWO_FLOATS :
732 * IN struct two_floats_t two_floats
733 ****************************************************************/
085dd6e6
JM		 734#ifdef PROTOTYPES
735void print_two_floats (struct two_floats_t two_floats)
736#else
c906108c
SS		 737void print_two_floats ( two_floats )
738struct two_floats_t two_floats;
085dd6e6 739#endif
c906108c
SS		 740{
741
742 printf("Contents of two_floats_t: \n\n");
743 printf("%f\t%f\n", two_floats.float1, two_floats.float2);
744}
745
746/*****************************************************************
747 * PRINT_TWO_CHARS :
748 * IN struct two_char_t two_char
749 ****************************************************************/
085dd6e6
JM		 750#ifdef PROTOTYPES
751void print_two_chars (struct two_char_t two_char)
752#else
c906108c
SS		 753void print_two_chars ( two_char )
754struct two_char_t two_char;
085dd6e6 755#endif
c906108c
SS		 756{
757
758 printf("Contents of two_char_t: \n\n");
759 printf("%c\t%c\n", two_char.ch1, two_char.ch2);
760}
761
762/*****************************************************************
763 * PRINT_THREE_CHARS :
764 * IN struct three_char_t three_char
765 ****************************************************************/
085dd6e6
JM		 766#ifdef PROTOTYPES
767void print_three_chars (struct three_char_t three_char)
768#else
c906108c
SS		 769void print_three_chars ( three_char )
770struct three_char_t three_char;
085dd6e6 771#endif
c906108c
SS		 772{
773
774 printf("Contents of three_char_t: \n\n");
775 printf("%c\t%c\t%c\n", three_char.ch1, three_char.ch2, three_char.ch3);
776}
777
778/*****************************************************************
779 * PRINT_FIVE_CHARS :
780 * IN struct five_char_t five_char
781 ****************************************************************/
085dd6e6
JM		 782#ifdef PROTOTYPES
783void print_five_chars (struct five_char_t five_char)
784#else
c906108c
SS		 785void print_five_chars ( five_char )
786struct five_char_t five_char;
085dd6e6 787#endif
c906108c
SS		 788{
789
790 printf("Contents of five_char_t: \n\n");
791 printf("%c\t%c\t%c\t%c\t%c\n", five_char.ch1, five_char.ch2,
792 five_char.ch3, five_char.ch4,
793 five_char.ch5);
794}
795
796/*****************************************************************
797 * PRINT_INT_CHAR_COMBO :
798 * IN struct int_char_combo_t int_char_combo
799 ****************************************************************/
085dd6e6
JM		 800#ifdef PROTOTYPES
801void print_int_char_combo (struct int_char_combo_t int_char_combo)
802#else
c906108c
SS		 803void print_int_char_combo ( int_char_combo )
804struct int_char_combo_t int_char_combo;
085dd6e6 805#endif
c906108c
SS		 806{
807
808 printf("Contents of int_char_combo_t: \n\n");
809 printf("%d\t%c\n", int_char_combo.int1, int_char_combo.ch1);
810}
811
812/*****************************************************************
813 * PRINT_STRUCT_REP :
814 * The last parameter must go onto the stack rather than into a register.
815 * This is a good function to call to test small structures.
816 * IN struct small_rep_info_t struct1
817 * IN struct small_rep_info_t struct2
818 * IN struct small_rep_info_t struct3
819 ****************************************************************/
085dd6e6
JM		 820#ifdef PROTOTYPES
821void print_struct_rep(
822 struct small_rep_info_t struct1,
823 struct small_rep_info_t struct2,
824 struct small_rep_info_t struct3)
825#else
c906108c
SS		 826void print_struct_rep( struct1, struct2, struct3)
827 struct small_rep_info_t struct1;
828 struct small_rep_info_t struct2;
829 struct small_rep_info_t struct3;
085dd6e6 830#endif
c906108c
SS		 831{
832
833
834 printf("Contents of struct1: \n\n");
835 printf("%10d%10d\n", struct1.value, struct1.head);
836 printf("Contents of struct2: \n\n");
837 printf("%10d%10d\n", struct2.value, struct2.head);
838 printf("Contents of struct3: \n\n");
839 printf("%10d%10d\n", struct3.value, struct3.head);
840
841}
842
843/*****************************************************************
844 * SUM_STRUCT_PRINT :
845 * The last two parameters must go onto the stack rather than into a register.
846 * This is a good function to call to test small structures.
847 * IN struct small_rep_info_t struct1
848 * IN struct small_rep_info_t struct2
849 * IN struct small_rep_info_t struct3
850 * IN struct small_rep_info_t struct4
851 ****************************************************************/
085dd6e6
JM		 852#ifdef PROTOTYPES
853void sum_struct_print (
854 int seed,
855 struct small_rep_info_t struct1,
856 struct small_rep_info_t struct2,
857 struct small_rep_info_t struct3,
858 struct small_rep_info_t struct4)
859#else
c906108c
SS		 860void sum_struct_print ( seed, struct1, struct2, struct3, struct4)
861 int seed;
862 struct small_rep_info_t struct1;
863 struct small_rep_info_t struct2;
864 struct small_rep_info_t struct3;
865 struct small_rep_info_t struct4;
085dd6e6 866#endif
c906108c
SS		 867{
868 int sum;
869
870 printf("Sum of the 4 struct values and seed : \n\n");
871 sum = seed + struct1.value + struct2.value + struct3.value + struct4.value;
872 printf("%10d\n", sum);
873}
874
875/*****************************************************************
876 * PRINT_SMALL_STRUCTS :
877 * This is a good function to call to test small structures.
878 * All of the small structures of odd sizes (40 bits, 8bits, etc.)
879 * are pushed onto the stack.
880 ****************************************************************/
085dd6e6
JM		 881#ifdef PROTOTYPES
882void print_small_structs (
883 struct small_rep_info_t struct1,
884 struct small_rep_info_t struct2,
885 struct small_rep_info_t struct3,
886 struct small_rep_info_t struct4,
887 struct bit_flags_t flags,
888 struct bit_flags_combo_t flags_combo,
889 struct three_char_t three_char,
890 struct five_char_t five_char,
891 struct int_char_combo_t int_char_combo,
892 struct one_double_t d1,
893 struct one_double_t d2,
894 struct one_double_t d3,
895 struct two_floats_t f1,
896 struct two_floats_t f2,
897 struct two_floats_t f3)
898#else
c906108c
SS		 899void print_small_structs ( struct1, struct2, struct3, struct4, flags,
900flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3)
901 struct small_rep_info_t struct1;
902 struct small_rep_info_t struct2;
903 struct small_rep_info_t struct3;
904 struct small_rep_info_t struct4;
905 struct bit_flags_t flags;
906 struct bit_flags_combo_t flags_combo;
907 struct three_char_t three_char;
908 struct five_char_t five_char;
909 struct int_char_combo_t int_char_combo;
910 struct one_double_t d1;
911 struct one_double_t d2;
912 struct one_double_t d3;
913 struct two_floats_t f1;
914 struct two_floats_t f2;
915 struct two_floats_t f3;
085dd6e6 916#endif
c906108c
SS		 917{
918 print_bit_flags(flags);
919 print_bit_flags_combo(flags_combo);
920 print_three_chars(three_char);
921 print_five_chars(five_char);
922 print_int_char_combo(int_char_combo);
923 sum_struct_print(10, struct1, struct2, struct3, struct4);
924 print_struct_rep(struct1, struct2, struct3);
925 print_one_double(d1);
926 print_one_double(d2);
927 print_one_double(d3);
928 print_two_floats(f1);
929 print_two_floats(f2);
930 print_two_floats(f3);
931}
932
933/*****************************************************************
934 * PRINT_LONG_ARG_LIST :
935 * This is a good function to call to test small structures.
936 * The first two parameters ( the doubles ) go into registers. The
937 * remaining arguments are pushed onto the stack. Depending on where
938 * print_long_arg_list is called from, the size of the argument list
939 * may force more space to be pushed onto the stack as part of the callers
940 * frame.
941 ****************************************************************/
085dd6e6
JM		 942#ifdef PROTOTYPES
943void print_long_arg_list (
944 double a,
945 double b,
946 int c,
947 int d,
948 int e,
949 int f,
950 struct small_rep_info_t struct1,
951 struct small_rep_info_t struct2,
952 struct small_rep_info_t struct3,
953 struct small_rep_info_t struct4,
954 struct bit_flags_t flags,
955 struct bit_flags_combo_t flags_combo,
956 struct three_char_t three_char,
957 struct five_char_t five_char,
958 struct int_char_combo_t int_char_combo,
959 struct one_double_t d1,
960 struct one_double_t d2,
961 struct one_double_t d3,
962 struct two_floats_t f1,
963 struct two_floats_t f2,
964 struct two_floats_t f3)
965#else
c906108c
SS		 966void print_long_arg_list ( a, b, c, d, e, f, struct1, struct2, struct3,
967struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1,d2,d3,
968f1, f2, f3 )
969 double a;
970 double b;
971 int c;
972 int d;
973 int e;
974 int f;
975 struct small_rep_info_t struct1;
976 struct small_rep_info_t struct2;
977 struct small_rep_info_t struct3;
978 struct small_rep_info_t struct4;
979 struct bit_flags_t flags;
980 struct bit_flags_combo_t flags_combo;
981 struct three_char_t three_char;
982 struct five_char_t five_char;
983 struct int_char_combo_t int_char_combo;
984 struct one_double_t d1;
985 struct one_double_t d2;
986 struct one_double_t d3;
987 struct two_floats_t f1;
988 struct two_floats_t f2;
989 struct two_floats_t f3;
085dd6e6 990#endif
c906108c
SS		 991{
992 printf("double : %f\n", a);
993 printf("double : %f\n", b);
994 printf("int : %d\n", c);
995 printf("int : %d\n", d);
996 printf("int : %d\n", e);
997 printf("int : %d\n", f);
998 print_small_structs( struct1, struct2, struct3, struct4, flags, flags_combo,
999 three_char, five_char, int_char_combo, d1, d2, d3,
1000 f1, f2, f3);
1001}
1002
1003
085dd6e6
JM		 1004#ifdef PROTOTYPES
1005void print_one_large_struct (struct array_rep_info_t linked_list1)
1006#else
c906108c
SS		 1007void print_one_large_struct( linked_list1 )
1008 struct array_rep_info_t linked_list1;
085dd6e6 1009#endif
c906108c
SS		 1010{
1011
1012 /* printf("Contents of linked list1: \n\n");
1013 printf("Element Value | Index of Next Element\n");
1014 printf("-------------------------------------\n");
1015 printf(" | \n");*/
1016 /*for (index = 0; index < 10; index++) {*/
1017
1018 printf("%10d%10d\n", linked_list1.values[0],
1019 linked_list1.next_index[0]);
1020 /*}*/
1021}
1022
1023/*****************************************************************
1024 * PRINT_ARRAY_REP :
1025 * The three structure parameters should fit into registers.
1026 * IN struct array_rep_info_t linked_list1
1027 * IN struct array_rep_info_t linked_list2
1028 * IN struct array_rep_info_t linked_list3
1029 ****************************************************************/
085dd6e6
JM		 1030#ifdef PROTOTYPES
1031void print_array_rep(
1032 struct array_rep_info_t linked_list1,
1033 struct array_rep_info_t linked_list2,
1034 struct array_rep_info_t linked_list3)
1035#else
c906108c
SS		 1036void print_array_rep( linked_list1, linked_list2, linked_list3 )
1037 struct array_rep_info_t linked_list1;
1038 struct array_rep_info_t linked_list2;
1039 struct array_rep_info_t linked_list3;
085dd6e6 1040#endif
c906108c
SS		 1041{
1042
1043 int index;
1044
1045 printf("Contents of linked list1: \n\n");
1046 printf("Element Value | Index of Next Element\n");
1047 printf("-------------------------------------\n");
1048 printf(" | \n");
1049 for (index = 0; index < 10; index++) {
1050
1051 printf("%10d%10d\n", linked_list1.values[index],
1052 linked_list1.next_index[index]);
1053 }
1054
1055 printf("Contents of linked list2: \n\n");
1056 printf("Element Value | Index of Next Element\n");
1057 printf("-------------------------------------\n");
1058 printf(" | \n");
1059 for (index = 0; index < 10; index++) {
1060
1061 printf("%10d%10d\n", linked_list2.values[index],
1062 linked_list2.next_index[index]);
1063 }
1064
1065 printf("Contents of linked list3: \n\n");
1066 printf("Element Value | Index of Next Element\n");
1067 printf("-------------------------------------\n");
1068 printf(" | \n");
1069 for (index = 0; index < 10; index++) {
1070
1071 printf("%10d%10d\n", linked_list3.values[index],
1072 linked_list3.next_index[index]);
1073 }
1074
1075}
1076
1077/*****************************************************************
1078 * SUM_ARRAY_PRINT :
1079 * The last structure parameter must be pushed onto the stack
1080 * IN int seed
1081 * IN struct array_rep_info_t linked_list1
1082 * IN struct array_rep_info_t linked_list2
1083 * IN struct array_rep_info_t linked_list3
1084 * IN struct array_rep_info_t linked_list4
1085 ****************************************************************/
085dd6e6
JM		 1086#ifdef PROTOTYPES
1087void sum_array_print (
1088 int seed,
1089 struct array_rep_info_t linked_list1,
1090 struct array_rep_info_t linked_list2,
1091 struct array_rep_info_t linked_list3,
1092 struct array_rep_info_t linked_list4)
1093#else
c906108c
SS		 1094void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_list4)
1095 int seed;
1096 struct array_rep_info_t linked_list1;
1097 struct array_rep_info_t linked_list2;
1098 struct array_rep_info_t linked_list3;
1099 struct array_rep_info_t linked_list4;
085dd6e6 1100#endif
c906108c
SS		 1101{
1102 int index;
1103 int sum;
1104
1105 printf("Sum of 4 arrays, by element (add in seed as well): \n\n");
1106 printf("Seed: %d\n", seed);
1107 printf("Element Index | Sum \n");
1108 printf("-------------------------\n");
1109 printf(" | \n");
1110
1111 for (index = 0; index < 10; index++) {
1112
1113 sum = seed + linked_list1.values[index] + linked_list2.values[index] +
1114 linked_list3.values[index] + linked_list4.values[index];
1115 printf("%10d%10d\n", index, sum);
1116 }
1117}
1118
1119/*****************************************************************
1120 * INIT_ARRAY_REP :
1121 * IN struct array_rep_info_t *linked_list
1122 * IN int seed
1123 ****************************************************************/
085dd6e6
JM		 1124#ifdef PROTOTYPES
1125void init_array_rep(
1126 struct array_rep_info_t *linked_list,
1127 int seed)
1128#else
c906108c
SS		 1129void init_array_rep( linked_list, seed )
1130 struct array_rep_info_t *linked_list;
1131 int seed;
085dd6e6 1132#endif
c906108c
SS		 1133{
1134
1135 int index;
1136
1137 for (index = 0; index < 10; index++) {
1138
1139 linked_list->values[index] = (2*index) + (seed*2);
1140 linked_list->next_index[index] = index + 1;
1141 }
1142 linked_list->head = 0;
1143}
1144
1145
1146int main () {
1147
1148 /* variables for array and enumerated type testing
1149 */
1b7c05e7
CV		 1150 static char char_array[121];
1151 static double double_array[9];
1152 static float float_array[15];
1153 static int integer_array[50];
1154 static int index;
1155 static id_int student_id = 23;
1156 static colors my_shirt = YELLOW;
c906108c
SS		 1157
1158 /* variables for large structure testing
1159 */
1b7c05e7
CV		 1160 static int number = 10;
1161 static struct array_rep_info_t *list1;
1162 static struct array_rep_info_t *list2;
1163 static struct array_rep_info_t *list3;
1164 static struct array_rep_info_t *list4;
c906108c
SS		 1165
1166 /* variables for testing a very long argument list
1167 */
1b7c05e7
CV		 1168 static double a;
1169 static double b;
1170 static int c;
1171 static int d;
1172 static int e;
1173 static int f;
c906108c
SS		 1174
1175 /* variables for testing a small structures and a very long argument list
1176 */
1b7c05e7
CV		 1177 static struct small_rep_info_t *struct1;
1178 static struct small_rep_info_t *struct2;
1179 static struct small_rep_info_t *struct3;
1180 static struct small_rep_info_t *struct4;
1181 static struct bit_flags_t *flags;
1182 static struct bit_flags_combo_t *flags_combo;
1183 static struct three_char_t *three_char;
1184 static struct five_char_t *five_char;
1185 static struct int_char_combo_t *int_char_combo;
1186 static struct one_double_t *d1;
1187 static struct one_double_t *d2;
1188 static struct one_double_t *d3;
1189 static struct two_floats_t *f1;
1190 static struct two_floats_t *f2;
1191 static struct two_floats_t *f3;
c906108c
SS		 1192
1193 /* Initialize arrays
1194 */
1195 for (index = 0; index < 120; index++) {
1196 if ((index%2) == 0) char_array[index] = 'Z';
1197 else char_array[index] = 'a';
085dd6e6
JM		 1198 }
1199 char_array[120] = '\0';
c906108c 1200
1b7c05e7 1201 for (index = 0; index < 9; index++) {
c906108c
SS		 1202 double_array[index] = index*23.4567;
1203 }
1204
1205 for (index = 0; index < 15; index++) {
1206 float_array[index] = index/7.02;
1207 }
1208
1209 for (index = 0; index < 50; index++) {
1210 integer_array[index] = -index;
1211 }
1212
1213 /* Print arrays
1214 */
1215 print_char_array(char_array);
1216 print_double_array(double_array);
1217 print_float_array(float_array);
1218 print_student_id_shirt_color(student_id, my_shirt);
1219 print_int_array(integer_array);
1220 print_all_arrays(integer_array, char_array, float_array, double_array);
1221
1222 /* Allocate space for large structures
1223 */
1224 list1 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
1225 list2 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
1226 list3 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
1227 list4 = (struct array_rep_info_t *)malloc(sizeof(struct array_rep_info_t));
1228
1229 /* Initialize large structures
1230 */
1231 init_array_rep(list1, 2);
1232 init_array_rep(list2, 4);
1233 init_array_rep(list3, 5);
1234 init_array_rep(list4, 10);
1235 printf("HELLO WORLD\n");
1236 printf("BYE BYE FOR NOW\n");
1237 printf("VERY GREEN GRASS\n");
1238
1239 /* Print large structures
1240 */
1241 sum_array_print(10, *list1, *list2, *list3, *list4);
1242 print_array_rep(*list1, *list2, *list3);
1243 print_one_large_struct(*list1);
1244
1245 /* Allocate space for small structures
1246 */
1247 struct1 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t));
1248 struct2 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t));
1249 struct3 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t));
1250 struct4 = (struct small_rep_info_t *)malloc(sizeof(struct small_rep_info_t));
1251 flags = (struct bit_flags_t *)malloc(sizeof(struct bit_flags_t));
1252 flags_combo = (struct bit_flags_combo_t *)malloc(sizeof(struct bit_flags_combo_t));
1253 three_char = (struct three_char_t *)malloc(sizeof(struct three_char_t));
1254 five_char = (struct five_char_t *)malloc(sizeof(struct five_char_t));
1255 int_char_combo = (struct int_char_combo_t *)malloc(sizeof(struct int_char_combo_t));
1256
1257 d1 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
1258 d2 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
1259 d3 = (struct one_double_t *)malloc(sizeof(struct one_double_t));
1260
1261 f1 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
1262 f2 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
1263 f3 = (struct two_floats_t *)malloc(sizeof(struct two_floats_t));
1264
1265 /* Initialize small structures
1266 */
1267 init_small_structs ( struct1, struct2, struct3, struct4, flags,
1268 flags_combo, three_char, five_char, int_char_combo,
1269 d1, d2, d3, f1, f2, f3);
1270
1271 /* Print small structures
1272 */
1273 print_small_structs ( *struct1, *struct2, *struct3, *struct4, *flags,
1274 *flags_combo, *three_char, *five_char, *int_char_combo,
1275 *d1, *d2, *d3, *f1, *f2, *f3);
1276
1277 /* Print a very long arg list
1278 */
591b8fa3
PDM		 1279 a = 22.25;
1280 b = 33.375;
c906108c
SS		 1281 c = 0;
1282 d = -25;
1283 e = 100;
1284 f = 2345;
1285
1286 print_long_arg_list ( a, b, c, d, e, f, *struct1, *struct2, *struct3, *struct4,
1287 *flags, *flags_combo, *three_char, *five_char, *int_char_combo,
1288 *d1, *d2, *d3, *f1, *f2, *f3);
1289
1290 /* Initialize small structures
1291 */
1292 init_one_double ( d1, 1.11111);
1293 init_one_double ( d2, -345.34);
1294 init_one_double ( d3, 546464.2);
1295 init_two_floats ( f1, 0.234, 453.1);
1296 init_two_floats ( f2, 78.345, 23.09);
1297 init_two_floats ( f3, -2.345, 1.0);
1298 init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1,
1299 (unsigned)0, (unsigned)1, (unsigned)0 );
1300 init_bit_flags_combo(flags_combo, (unsigned)1, (unsigned)0, 'y',
1301 (unsigned)1, (unsigned)0, 'n',
1302 (unsigned)1, (unsigned)0 );
1303 init_three_chars(three_char, 'x', 'y', 'z');
1304 init_five_chars(five_char, 'h', 'e', 'l', 'l', 'o');
1305 init_int_char_combo(int_char_combo, 13, '!');
1306 init_struct_rep(struct1, 10);
1307 init_struct_rep(struct2, 20);
1308 init_struct_rep(struct3, 30);
1309 init_struct_rep(struct4, 40);
1310
1311 compute_with_small_structs(35);
1312 loop_count();
1313 printf("HELLO WORLD\n");
1314 printf("BYE BYE FOR NOW\n");
1315 printf("VERY GREEN GRASS\n");
1316
1317 /* Print small structures
1318 */
1319 print_one_double(*d1);
1320 print_one_double(*d2);
1321 print_one_double(*d3);
1322 print_two_floats(*f1);
1323 print_two_floats(*f2);
1324 print_two_floats(*f3);
1325 print_bit_flags(*flags);
1326 print_bit_flags_combo(*flags_combo);
1327 print_three_chars(*three_char);
1328 print_five_chars(*five_char);
1329 print_int_char_combo(*int_char_combo);
1330 sum_struct_print(10, *struct1, *struct2, *struct3, *struct4);
1331 print_struct_rep(*struct1, *struct2, *struct3);
1332
1333 return 0;
1334}
1335
1336
1337
1338
1339
A mirror of the official binutils-gdb repository