C/C++ determination/reporting.
[dyninst.git] / dyninstAPI / tests / src / test1.mutatee.c
1
2 /* Test application (Mutatee) */
3
4 /* $Id: test1.mutatee.c,v 1.48 2000/06/20 21:45:57 wylie Exp $ */
5
6 #include <stdio.h>
7 #include <assert.h>
8 #include <sys/types.h>
9 #include <signal.h>
10 #include <string.h>
11 #include <stdlib.h>
12
13 #ifdef i386_unknown_nt4_0
14 #define WIN32_LEAN_AND_MEAN
15 #include <windows.h>
16 #else
17 #include <unistd.h>
18 #endif
19
20 #ifdef __cplusplus
21 #include "cpp_test.h"
22 #include <iostream.h>
23 #endif
24
25 #ifdef __cplusplus
26 int mutateeCplusplus = 1;
27 #else
28 int mutateeCplusplus = 0;
29 #endif
30
31 #if defined(sparc_sun_solaris2_4) || \
32     defined(alpha_dec_osf4_0) || \
33     defined(i386_unknown_linux2_0) || \
34     defined(i386_unknown_solaris2_5)
35 #include <dlfcn.h> /* For replaceFunction test */
36 #endif
37
38 /* Empty functions are sometimes compiled too tight for entry and exit
39    points.  The following macro is used to flesh out these
40    functions. (expanded to use on all platforms for non-gcc compilers jkh 10/99) */
41 volatile int dummy3__;
42
43 #define DUMMY_FN_BODY \
44   int dummy1__ = 1; \
45   int dummy2__ = 2; \
46   dummy3__ = dummy1__ + dummy2__
47
48 /* XXX Currently, there's a bug in the library that prevents a subroutine call
49  * instrumentation point from being recognized if it is the first instruction
50  * in a function.  The following variable is used in this program in a number
51  * of kludges to get around this.
52  */
53 int kludge;
54
55 /* control debug printf statements */
56 #define dprintf if (debugPrint) printf
57 int debugPrint = 0;
58
59 #define TRUE    1
60 #define FALSE   0
61
62 int runAllTests = TRUE;
63
64 #ifdef __cplusplus
65 #define MAX_TEST 44
66 #else 
67 #define MAX_TEST 32
68 #endif 
69
70 int runTest[MAX_TEST+1];
71 int passedTest[MAX_TEST+1];
72
73 #if defined(sparc_sun_solaris2_4) || defined(alpha_dec_osf4_0)
74 #if defined(mips_sgi_irix6_4) && (_MIPS_SIM == _MIPS_SIM_NABI32)
75 static char *libNameA = "libtestA_n32.so";
76 #else
77 static char *libNameA = "libtestA.so";
78 #endif
79 #endif
80
81 #define RET13_1 1300100
82
83 #define RAN17_1 1701000
84
85 #define RET17_1 1700100
86 #define RET17_2 1700200
87
88 #define MAGIC19_1 1900100
89 #define MAGIC19_2 1900200
90
91 /* These are copied in libtestA.c and libtestB.c */
92 #define MAGIC22_1   2200100
93 #define MAGIC22_2   2200200
94 #define MAGIC22_3   2200300
95 #define MAGIC22_4   2200400
96 #define MAGIC22_5A  2200510
97 #define MAGIC22_5B  2200520
98 #define MAGIC22_6   2200600
99 #define MAGIC22_7   2200700
100
101 int isAttached = 0;
102
103 int globalVariable1_1 = 0;
104 int globalVariable3_1 = 31;
105 int globalVariable4_1 = 41;
106 int globalVariable5_1 = 51;
107 int globalVariable5_2 = 51;
108
109 int constVar0 = 0;
110 int constVar1 = 1;
111 int constVar2 = 2;
112 int constVar3 = 3;
113 int constVar4 = 4;
114 int constVar5 = 5;
115 int constVar6 = 6;
116 int constVar7 = 7;
117 int constVar9 = 9;
118 int constVar10 = 10;
119 int constVar60 = 60;
120 int constVar64 = 64;
121 int constVar66 = 66;
122 int constVar67 = 67;
123
124 int globalVariable6_1 = (int)0xdeadbeef;
125 int globalVariable6_2 = (int)0xdeadbeef;
126 int globalVariable6_3 = (int)0xdeadbeef;
127 int globalVariable6_4 = (int)0xdeadbeef;
128 int globalVariable6_5 = (int)0xdeadbeef;
129 int globalVariable6_6 = (int)0xdeadbeef;
130 int globalVariable6_1a = (int)0xdeadbeef;
131 int globalVariable6_2a = (int)0xdeadbeef;
132 int globalVariable6_3a = (int)0xdeadbeef;
133 int globalVariable6_4a = (int)0xdeadbeef;
134 int globalVariable6_5a = (int)0xdeadbeef;
135 int globalVariable6_6a = (int)0xdeadbeef;
136
137 int globalVariable7_1 = 71, globalVariable7_2 = 71,
138     globalVariable7_3 = 71, globalVariable7_4 = 71,
139     globalVariable7_5 = 71, globalVariable7_6 = 71,
140     globalVariable7_7 = 71, globalVariable7_8 = 71,
141     globalVariable7_9 = 71, globalVariable7_10 = 71,
142     globalVariable7_11 = 71, globalVariable7_12 = 71,
143     globalVariable7_13 = 71, globalVariable7_14 = 71,
144     globalVariable7_15 = 71, globalVariable7_16 = 71;
145
146
147 int globalVariable7_1a = 73, globalVariable7_2a = 73,
148     globalVariable7_3a = 73, globalVariable7_4a = 73,
149     globalVariable7_5a = 73, globalVariable7_6a = 73,
150     globalVariable7_7a = 73, globalVariable7_8a = 73,
151     globalVariable7_9a = 73, globalVariable7_10a = 73,
152     globalVariable7_11a = 73, globalVariable7_12a = 73,
153     globalVariable7_13a = 73, globalVariable7_14a = 73,
154     globalVariable7_15a = 73, globalVariable7_16a = 73;
155
156 int globalVariable8_1 = 1;
157
158 int globalVariable10_1 = 0, globalVariable10_2 = 0, 
159     globalVariable10_3 = 0, globalVariable10_4 = 0;
160
161 int globalVariable11_1 = 0, globalVariable11_2 = 0, 
162     globalVariable11_3 = 0, globalVariable11_4 = 0, globalVariable11_5 = 0;
163
164 int globalVariable12_1 = 0;
165
166 int globalVariable13_1 = 0;
167
168 int globalVariable14_1 = 0;
169 int globalVariable14_2 = 0;
170
171 int globalVariable15_1 = 0;
172 int globalVariable15_2 = 0;
173 int globalVariable15_3 = 0;
174 int globalVariable15_4 = 0;
175
176 int globalVariable16_1 = 0;
177 int globalVariable16_2 = 0;
178 int globalVariable16_3 = 0;
179 int globalVariable16_4 = 0;
180 int globalVariable16_5 = 0;
181 int globalVariable16_6 = 0;
182 int globalVariable16_7 = 0;
183 int globalVariable16_8 = 0;
184 int globalVariable16_9 = 0;
185 int globalVariable16_10 = 0;
186
187 int globalVariable17_1 = 0;
188 int globalVariable17_2 = 0;
189
190 int globalVariable18_1 = 42;
191
192 int globalVariable19_1 = (int)0xdeadbeef;
193 int globalVariable19_2 = (int)0xdeadbeef;
194
195 int globalVariable20_1 = (int)0xdeadbeef;
196 double globalVariable20_2 = 0.0;
197
198 int globalVariable22_1 = 0;
199 int globalVariable22_2 = 0;
200 int globalVariable22_3 = 0;
201 int globalVariable22_4 = 0;
202
203 unsigned globalVariable30_1 = 0;
204 unsigned globalVariable30_2 = 0;
205
206 unsigned globalVariable30_3 = 0;
207 unsigned globalVariable30_4 = 0;
208 unsigned globalVariable30_5 = 0;
209 unsigned globalVariable30_6 = 0;
210
211 int globalVariable31_1 = 0;
212 int globalVariable31_2 = 0;
213 int globalVariable31_3 = 0;
214 int globalVariable31_4 = 0;
215
216 int globalVariable32_1 = 0;
217 int globalVariable32_2 = 0;
218 int globalVariable32_3 = 0;
219 int globalVariable32_4 = 0;
220
221 #define TEST20_A 3
222 #define TEST20_B 4.3
223 #define TEST20_C 7
224 #define TEST20_D 6.4
225 #define TEST20_TIMES 41
226
227 /*
228  * Check to see if the mutator has attached to us.
229  */
230 int checkIfAttached()
231 {
232     return isAttached;
233 }
234
235 /*
236  * Stop the process (in order to wait for the mutator to finish what it's
237  * doing and restart us).
238  */
239 #if defined(alpha_dec_osf4_0) && defined(__GNUC__)
240 static long long int  beginFP;
241 #endif
242 void stop_process()
243 {
244 #ifdef i386_unknown_nt4_0
245     DebugBreak();
246 #else
247
248 #if defined(alpha_dec_osf4_0) && defined(__GNUC__)
249     /* This GCC-specific hack doesn't compile with other compilers, 
250        which is unfortunate, since the native build test fails part 15
251        with the error "process did not signal mutator via stop". */
252     /* It also doesn't appear to be necessary when compiling with gcc-2.8.1,
253        which makes its existance even more curious. */
254     register long int fp asm("15");
255
256     beginFP = fp;
257 #endif
258
259 #ifdef DETACH_ON_THE_FLY
260     kill(getpid(), SIGILL);
261 #else
262     kill(getpid(), SIGSTOP);
263 #endif
264
265 #if defined(alpha_dec_osf4_0) && defined(__GNUC__)
266     fp = beginFP;
267 #endif
268
269 #endif
270 }
271
272 /*
273  * Determine if two doubles are close to being equal (for our purposes, that
274  * means to ten decimal places).
275  */
276 int eq_doubles(double a, double b)
277 {
278     double diff = a - b;
279
280     if (diff < 0) diff = -diff;
281
282     if (diff < 0.00000000001) return 1;
283     else return 0;
284 }
285
286 /*
287  * Verify that a scalar value of a variable is what is expected
288  *
289  */
290 void verifyScalarValue(char *name, int a, int value, int testNum, char *testName)
291 {
292     if (a != value) {
293         if (passedTest[testNum]) 
294             printf("**Failed** test %d (%s)\n", testNum, testName);
295         printf("  %s = %d, not %d\n", name, a, value);
296         passedTest[testNum] = FALSE;
297     }
298 }
299
300 /*
301  * Verify that a passed array has the correct value in the passed element.
302  *
303  */
304 void verifyValue(char *name, int *a, int index, int value, int tst, char *tn)
305 {
306     if (a[index] != value) {
307         if (passedTest[tst]) printf("**Failed** test #%d (%s)\n", tst, tn);
308         printf("  %s[%d] = %d, not %d\n", 
309             name, index, a[index], value);
310         passedTest[tst] = FALSE;
311     }
312 }
313
314 void call1_1()
315 {
316     dprintf("call1() called - setting globalVariable1_1 = 11\n");
317     globalVariable1_1 = 11;
318 }
319
320 void call2_1(int arg1, int arg2, char *arg3)
321 {
322     if ((arg1 == 1) && (arg2 == 2) && (!strcmp(arg3, "testString2_1"))) {
323         printf("Passed test #2 (three parameter function)\n");
324         passedTest[2] = TRUE;
325     } else {
326         printf("**Failed** test #2 (three parameter function)\n");
327         if (arg1 != 1) 
328             printf("    arg1 = %d, should be 1\n", arg1);
329         if (arg1 != 2) 
330             printf("    arg2 = %d, should be 2\n", arg2);
331         if (strcmp(arg3, "testString2_1")) 
332             printf("    arg3 = %s, should be \"testString2_1\"\n", arg3);
333     }
334 }
335
336 void call3_1(int arg1, int arg2)
337 {
338     if ((arg1 == 31) && (arg2 == 32))  {
339         printf("Passed test #3 (passing variables to functions)\n");
340         passedTest[3] = TRUE;
341     } else {
342         printf("**Failed** test #3 (passing variables to functions)\n");
343         printf("    arg1 = %d, should be 31\n", arg1);
344         printf("    arg2 = %d, should be 32\n", arg2);
345     }
346 }
347
348 int call9_1(int p1, int p2, int p3, int p4, int p5)
349 {
350     int x; 
351     x = (((p1 + p2) + (p3 + p4) + (p5)));
352     if (x != (91 + 92 + 93 + 94 + 95 )) {
353       printf("**Failed** test case #9 (preserve registers - funcCall)\n");
354       if (p1 != 91) printf("    call9_1 parameter 1 is %d not 91\n", p1);
355       if (p2 != 92) printf("    call9_1 parameter 2 is %d not 92\n", p2);
356       if (p3 != 93) printf("    call9_1 parameter 2 is %d not 93\n", p3);
357       if (p4 != 94) printf("    call9_1 parameter 4 is %d not 94\n", p4);
358       if (p5 != 95) printf("    call9_1 parameter 5 is %d not 95\n", p5);
359       exit(-1);
360     }
361     dprintf("inside call9_1\n");
362     return x;
363 }
364
365 void call10_1()
366 {
367     if (globalVariable10_4 == 0) {
368         globalVariable10_4 = 1; /* update marker of call order */
369         globalVariable10_1 = 1; /* flag that this was called first */
370     }
371 }
372
373
374 void call10_2()
375 {
376     if (globalVariable10_4 == 1) {
377         globalVariable10_4 = 2; /* update marker of call order */
378         globalVariable10_2 = 1; /* flag that this was called first */
379     }
380 }
381
382 void call10_3()
383 {
384     if (globalVariable10_4 == 2) {
385         globalVariable10_4 = 3; /* update marker of call order */
386         globalVariable10_3 = 1; /* flag that this was called first */
387     }
388 }
389
390 void call11_1()
391
392     if (globalVariable11_1 == 0) globalVariable11_2 = 1;
393 }
394
395 void call11_2()
396
397     if (globalVariable11_1 == 1) globalVariable11_3 = 1;
398 }
399
400 void call11_3()
401
402     if (globalVariable11_1 == 2) globalVariable11_4 = 1;
403 }
404
405 void call11_4()
406
407     if (globalVariable11_1 == 3) globalVariable11_5 = 1;
408
409     if (globalVariable11_2 && globalVariable11_3 && 
410         globalVariable11_4 && globalVariable11_5) {
411         printf("Passed test #11 (snippets at entry,exit,call)\n");
412         passedTest[11] = TRUE;
413     } else {
414         printf("**Failed test #11 (snippets at entry,exit,call)\n");
415         if (!globalVariable11_2) 
416             printf("    entry snippet not called at the correct time\n");
417         if (!globalVariable11_3) 
418             printf("    pre call snippet not called at the correct time\n");
419         if (!globalVariable11_4) 
420             printf("    post call snippet not called at the correct time\n");
421         if (!globalVariable11_5) 
422             printf("    exit snippet not called at the correct time\n");
423     }
424 }
425
426 void call12_1()
427 {
428     globalVariable12_1++;
429 }
430
431 void call13_1(int a1, int a2, int a3, int a4, int a5)
432 {
433     if (a1 == 131) globalVariable13_1 |= 1;
434     if (a2 == 132) globalVariable13_1 |= 2;
435     if (a3 == 133) globalVariable13_1 |= 4;
436     if (a4 == 134) globalVariable13_1 |= 8;
437     if (a5 == 135) globalVariable13_1 |= 16;
438     dprintf("a1 = %d\n", a1);
439     dprintf("a2 = %d\n", a2);
440     dprintf("a3 = %d\n", a3);
441     dprintf("a4 = %d\n", a4);
442     dprintf("a5 = %d\n", a5);
443 }
444
445 void call13_2(int ret)
446 {
447     if (ret == RET13_1) globalVariable13_1 |= 32;
448 }
449
450 void call14_1()
451 {
452     globalVariable14_1 = 1;
453 }
454
455 void call15_1()
456 {
457     globalVariable15_1++;
458 }
459
460 void call15_2()
461 {
462     globalVariable15_2++;
463 }
464
465 void call15_3()
466 {
467     globalVariable15_3++;
468 }
469
470 int call17_1(int p1) 
471
472      /* make sure the function uses lots of registers */
473
474      int a1, a2, a3, a4, a5, a6, a7;
475
476      dprintf("call17_1 (p1=%d)\n", p1);
477      assert(p1!=0); /* shouldn't try to divide by zero! */
478      assert(p1==1); /* actually only expect calls with p1==1 */
479
480      a1 = p1;
481      a2 = a1 + p1;
482      a3 = a1 * a2;
483      a4 = a3 / p1;
484      a5 = a4 + p1;
485      a6 = a5 + a1;
486      a7 = a6 + p1;
487
488      dprintf("call17_1 (ret=%d)\n", a7);
489
490      return a7; 
491 }
492
493 int call17_2(int p1) 
494 {
495      /* make sure the function uses lots of registers */
496
497      int a1, a2, a3, a4, a5, a6, a7;
498
499      dprintf("call17_2 (p1=%d)\n", p1);
500      assert(p1!=0); /* shouldn't try to divide by zero! */
501      assert(p1==1); /* actually only expect calls with p1==1 */
502
503      a1 = p1;
504      a2 = a1 + p1;
505      a3 = a1 * a2;
506      a4 = a3 / p1;
507      a5 = a4 + p1;
508      a6 = a5 + a1;
509      a7 = a6 + p1;
510      globalVariable17_2 = RAN17_1;
511
512      dprintf("call17_2 (ret=%d)\n", a7);
513
514      return a7; 
515 }
516
517 void call19_1()
518 {
519     globalVariable19_1 = MAGIC19_1;
520 }
521
522 void call19_2()
523 {
524     globalVariable19_2 = MAGIC19_2;
525 }
526
527 volatile int ta = TEST20_A;
528 volatile double tb = TEST20_B;
529
530 void call20_1()
531 {
532     globalVariable20_1 = ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
533                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
534                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
535                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta
536                          ))))))))))))))))))))))))))))))))))))))));
537
538     globalVariable20_2 = tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
539                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
540                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
541                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb
542                          ))))))))))))))))))))))))))))))))))))))));
543 }
544
545 void call22_1(int x)
546 {
547      globalVariable22_1 += x;
548      globalVariable22_1 += MAGIC22_1;
549 }                   
550                     
551 void call22_2(int x)
552 {                   
553      globalVariable22_1 += x;
554      globalVariable22_1 += MAGIC22_2;
555 }                   
556                     
557 void call22_3(int x)
558 {                   
559      globalVariable22_2 += x;
560      globalVariable22_2 += MAGIC22_3;
561 }                   
562                     
563 void call22_7(int x)
564 {                   
565      globalVariable22_4 += x;
566      globalVariable22_4 += MAGIC22_7;
567 }
568
569 #if defined(sparc_sun_solaris2_4) || \
570     defined(i386_unknown_solaris2_5) || \
571     defined(i386_unknown_linux2_0) || \
572     defined(rs6000_ibm_aix4_1) || \
573     defined(alpha_dec_osf4_0)
574
575 /* this function has to be only 1 line for test30 to pass */
576 /* these two lines has to be together otherwise test30 will fail */
577 unsigned globalVariable30_7 = __LINE__;
578 void call30_1(){ globalVariable30_1 = __LINE__; globalVariable30_2 = (unsigned)call30_1;}
579
580 #endif
581
582 /*
583  * This is a series of nearly empty functions to attach code to 
584  */
585
586 /*
587  * Start of Test #1
588  */
589 void func1_1()
590 {
591     void func1_2();
592
593     dprintf("Value of globalVariable1_1 is %d.\n", globalVariable1_1);
594
595     func1_2();
596
597     dprintf("Value of globalVariable1_1 is now %d.\n", globalVariable1_1);
598
599     if (globalVariable1_1 == 11) {
600         printf("\nPassed test #1 (zero arg function call)\n");
601         passedTest[1] = TRUE;
602     } else {
603         printf("\n**Failed** test #1 (zero arg function call)\n");
604     }
605 }
606
607 void func1_2() { dprintf("func1_2 () called\n"); }
608
609
610 /*
611  * Start of Test #2
612  */
613 void func2_1() { dprintf("func2_1 () called\n"); }
614
615 /*
616  * Start of Test #3
617  */
618 void func3_1() { dprintf("func3_1 () called\n"); }
619
620 /*
621  * Start of Test #4 - sequence
622  *      Run two expressions and verify correct ordering.
623  */
624 void func4_1()
625 {
626     void func4_2();
627     func4_2();
628     if (globalVariable4_1 == 41) {
629         printf("**Failed** test #4 (sequence)\n");
630         printf("    none of the items were executed\n");
631     } else if (globalVariable4_1 == 42) {
632         printf("**Failed** test #4 (sequence)\n");
633         printf("    first item was the last (or only) one to execute\n");
634     } else if (globalVariable4_1 == 43) {
635         printf("Passed test #4 (sequence)\n");
636         passedTest[4] = TRUE;
637     }
638 }
639
640 void func4_2() { dprintf("func4_1 () called\n"); }
641
642
643 /* 
644  * Start of Test #5 - if w.o. else
645  *      Execute two if statements, one true and one false.
646  */
647 void func5_1()
648 {
649     void func5_2();
650     func5_2();
651
652     if ((globalVariable5_1 == 51) && (globalVariable5_2 == 53)) {
653         printf("Passed test #5 (if w.o. else)\n");
654         passedTest[5] = TRUE;
655     } else {
656         printf("**Failed** test #5 (if w.o. else)\n");
657         if (globalVariable5_1 != 51) {
658             printf("    condition executed for false\n");
659         }
660         if (globalVariable5_2 != 53) {
661             printf("    condition not executed for true\n");
662         }
663     }
664 }
665
666 void func5_2() { dprintf("func5_1 () called\n"); }
667
668
669 /*
670  * Start of Test #6 - arithmetic operators
671  *      Verify arithmetic operators:
672  *              constant integer addition
673  *              constant integer subtraction
674  *              constant integer divide (using large constants)
675  *              constant integer divide (small consts)
676  *              constant integer multiply 
677  *              constant comma operator
678  *              variable integer addition
679  *              variable integer subtraction
680  *              variable integer divide (using large constants)
681  *              variable integer divide (small consts)
682  *              variable integer multiply 
683  *              variable comma operator
684  *
685  *      constant - use constant expressions
686  *      variable - use variables in the expressions
687  *
688  */
689 void func6_1()
690 {
691     void func6_2();
692     func6_2();
693     if ((globalVariable6_1 == 60+2) && (globalVariable6_2 == 64-1) &&
694         (globalVariable6_3 == 66/3) && (globalVariable6_4 == 67/3) &&
695         (globalVariable6_5 == 6 * 5) && (globalVariable6_6 == 3) &&
696         (globalVariable6_1a == 60+2) && (globalVariable6_2a == 64-1) &&
697         (globalVariable6_3a == 66/3) && (globalVariable6_4a == 67/3) &&
698         (globalVariable6_5a == 6 * 5) && (globalVariable6_6a == 3)) {
699         printf("Passed test #6 (arithmetic operators)\n");
700         passedTest[6] = TRUE;
701     } else {
702         printf("**Failed** test #6 (arithmetic operators)\n");
703         if (globalVariable6_1 != 60+2) 
704             printf("    addition error 60+2 got %d\n", globalVariable6_1);
705         if (globalVariable6_2 != 64-1) 
706             printf("    subtraction error 64-1 got %d\n", globalVariable6_2);
707         if (globalVariable6_3 != 66/3)
708             printf("    division error 66/3 got %d\n", globalVariable6_3);
709         if (globalVariable6_4 != 67/3)
710             printf("    division error 67/3 got %d\n", globalVariable6_4);
711         if (globalVariable6_5 != 6 * 5)
712             printf("    mult error 6*5 got %d\n", globalVariable6_5);
713         if (globalVariable6_6 != 3)
714             printf("    comma error 10,3 got %d\n", globalVariable6_6);
715         if (globalVariable6_1a != 60+2) 
716             printf("    addition error 60+2 got %d\n", globalVariable6_1a);
717         if (globalVariable6_2a != 64-1) 
718             printf("    subtraction error 64-1 got %d\n", globalVariable6_2a);
719         if (globalVariable6_3a != 66/3)
720             printf("    division error 66/3 got %d\n", globalVariable6_3a);
721         if (globalVariable6_4a != 67/3)
722             printf("    division error 67/3 got %d\n", globalVariable6_4a);
723         if (globalVariable6_5a != 6 * 5)
724             printf("    mult error 6*5 got %d\n", globalVariable6_5a);
725         if (globalVariable6_6a != 3)
726             printf("    comma error 10,3 got %d\n", globalVariable6_6a);
727     }
728 }
729
730 void func6_2() { dprintf("func6_2 () called\n"); }
731
732
733 /*
734  * Start Test Case #7 - relational operators
735  *      Generate all relational operators (eq, gt, le, ne, ge, and, or) 
736  *      in both the true and false forms.
737  */
738
739 void fail7Print(int tCase, int fCase, char *op)
740 {
741     if (tCase != 72) 
742         printf(" operator %s was not true when it should be - const expr\n",
743             op); 
744     if (fCase != 71) 
745        printf(" operator %s was not false when it should be - const expr\n",
746             op); 
747 }
748
749 void fail7aPrint(int tCase, int fCase, char *op)
750 {
751     if (tCase != 74) 
752         printf(" operator %s was not true when it should be - var expr\n", op); 
753     if (fCase != 73) 
754         printf(" operator %s was not false when it should be - var expr\n",op); 
755 }
756
757 void func7_1()
758 {
759     void func7_2();
760
761     func7_2();
762     if ((globalVariable7_1 == 72) && (globalVariable7_2 == 71) &&
763         (globalVariable7_3 == 72) && (globalVariable7_4 == 71) &&
764         (globalVariable7_5 == 72) && (globalVariable7_6 == 71) &&
765         (globalVariable7_7 == 72) && (globalVariable7_8 == 71) &&
766         (globalVariable7_9 == 72) && (globalVariable7_10 == 71) &&
767         (globalVariable7_11 == 72) && (globalVariable7_12 == 71) &&
768         (globalVariable7_13 == 72) && (globalVariable7_14 == 71) &&
769         (globalVariable7_15 == 72) && (globalVariable7_16 == 71) &&
770         (globalVariable7_1a == 74) && (globalVariable7_2a == 73) &&
771         (globalVariable7_3a == 74) && (globalVariable7_4a == 73) &&
772         (globalVariable7_5a == 74) && (globalVariable7_6a == 73) &&
773         (globalVariable7_7a == 74) && (globalVariable7_8a == 73) &&
774         (globalVariable7_9a == 74) && (globalVariable7_10a == 73) &&
775         (globalVariable7_11a == 74) && (globalVariable7_12a == 73) &&
776         (globalVariable7_13a == 74) && (globalVariable7_14a == 73) &&
777         (globalVariable7_15a == 74) && (globalVariable7_16a == 73)) { 
778         printf("Passed test #7 (relational operators)\n");
779         passedTest[7] = TRUE;
780     } else {
781         printf("**Failed** test #7 (relational operators)\n");
782         fail7Print(globalVariable7_1, globalVariable7_2, "BPatch_lt");
783         fail7Print(globalVariable7_3, globalVariable7_4, "BPatch_eq");
784         fail7Print(globalVariable7_5, globalVariable7_6, "BPatch_gt");
785         fail7Print(globalVariable7_7, globalVariable7_8, "BPatch_le");
786         fail7Print(globalVariable7_9, globalVariable7_10, "BPatch_ne");
787         fail7Print(globalVariable7_11, globalVariable7_12, "BPatch_ge");
788         fail7Print(globalVariable7_13, globalVariable7_14, "BPatch_and");
789         fail7Print(globalVariable7_15, globalVariable7_16, "BPatch_or");
790
791         fail7aPrint(globalVariable7_1a, globalVariable7_2a, "BPatch_lt");
792         fail7aPrint(globalVariable7_3a, globalVariable7_4a, "BPatch_eq");
793         fail7aPrint(globalVariable7_5a, globalVariable7_6a, "BPatch_gt");
794         fail7aPrint(globalVariable7_7a, globalVariable7_8a, "BPatch_le");
795         fail7aPrint(globalVariable7_9a, globalVariable7_10a, "BPatch_ne");
796         fail7aPrint(globalVariable7_11a, globalVariable7_12a, "BPatch_ge");
797         fail7aPrint(globalVariable7_13a, globalVariable7_14a, "BPatch_and");
798         fail7aPrint(globalVariable7_15a, globalVariable7_16a, "BPatch_or");
799     }
800 }
801
802 void func7_2() { dprintf("func7_2 () called\n"); }
803
804 /*
805  * Test #8 - preserve registers - expr
806  *      Verify the complex AST expressions do not clobber application
807  *      paramter registers.
808  */
809 void func8_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
810              int p8, int p9, int p10)
811 {
812     dprintf("func8_1 (...) called\n");
813     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) && 
814         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
815         printf("Passed test #8 (preserve registers - expr)\n");
816         passedTest[8] = TRUE;
817     } else {
818         printf("**Failed** test #8 (preserve registers - expr )\n");
819         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
820         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
821         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
822         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
823         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
824         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
825         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
826         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
827         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
828         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
829     }
830 }
831
832 /*
833  * Test #9 - reserve registers - funcCall
834  *      Verify the a snippet that calls a function does not clobber the
835  *      the parameter registers.
836  */
837 void func9_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
838              int p8, int p9, int p10)
839 {
840     dprintf("func9_1 (...) called\n");
841     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) && 
842         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
843         printf("Passed test #9 (preserve registers - funcCall)\n");
844         passedTest[9] = TRUE;
845     } else {
846         printf("**Failed** test #9 (preserve registers - funcCall )\n");
847         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
848         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
849         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
850         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
851         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
852         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
853         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
854         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
855         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
856         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
857     }
858 }
859
860 /*
861  * Test #10 - insert snippet order
862  *      Verify that a snippet are inserted in the requested order.  We insert
863  *      one snippet and then request two more to be inserted.  One before
864  *      the first snippet and one after it.
865  */
866 void func10_1()
867 {
868     if ((globalVariable10_1 == 1) && (globalVariable10_2 == 1) && 
869         (globalVariable10_3 == 1) && (globalVariable10_4 == 3)) {
870         printf("Passed test #10 (insert snippet order)\n");
871         passedTest[10] = TRUE;
872     } else {
873         printf("** Failed test #10 (insert snippet order)\n");
874         if (!globalVariable10_1) 
875             printf("    call10_1 was not called first\n");
876         if (!globalVariable10_2) 
877             printf("    call10_2 was not called second\n");
878         if (!globalVariable10_3) 
879             printf("    call10_3 was not called third\n");
880     }
881 }
882
883 /*
884  * Test #11 - snippets at entry,exit,call
885  */     
886 void func11_2() {
887     globalVariable11_1 = 2;
888 }
889
890 void func11_1()
891 {
892     globalVariable11_1 = 1;
893     func11_2();
894     globalVariable11_1 = 3;
895
896 }
897
898 /*
899  * Test #12 - insert/remove and malloc/free
900  */     
901 void func12_2()
902 {
903     DUMMY_FN_BODY;
904 }
905
906 void func12_1()
907 {
908     func12_2();
909     stop_process();
910     func12_2();
911     if (globalVariable12_1 == 1) {
912         printf("Passed test #12 (insert/remove and malloc/free)\n");
913         passedTest[12] = TRUE;
914     } else {
915         printf("**Failed test #12 (insert/remove and malloc/free)\n");
916     }
917 }
918
919 /*
920  * Test #13 - paramExpr,retExpr,nullExpr
921  *      Test various expressions
922  */
923 int func13_2()
924 {
925     return(RET13_1);
926 }
927
928 void func13_1(int p1, int p2, int p3, int p4, int p5)
929 {
930     func13_2();
931
932     if ((p1 == 131) && (p2 == 132) && (p3 == 133) && 
933         (p4 == 134) && (p5 == 135) && (globalVariable13_1 == 63)) {
934         printf("Passed test #13 (paramExpr,retExpr,nullExpr)\n");
935         passedTest[13] = TRUE;
936     } else {
937         printf("**Failed test #13 (paramExpr,retExpr,nullExpr)\n");
938         if (p1 != 131) printf("  parameter 1 is %d, not 131\n", p1);
939         if (p2 != 132) printf("  parameter 2 is %d, not 132\n", p2);
940         if (p3 != 133) printf("  parameter 3 is %d, not 133\n", p3);
941         if (p4 != 134) printf("  parameter 4 is %d, not 134\n", p4);
942         if (p5 != 135) printf("  parameter 5 is %d, not 135\n", p5);
943         if (!(globalVariable13_1 & 1)) printf("    passed param a1 wrong\n");
944         if (!(globalVariable13_1 & 2)) printf("    passed param a2 wrong\n");
945         if (!(globalVariable13_1 & 4)) printf("    passed param a3 wrong\n");
946         if (!(globalVariable13_1 & 8)) printf("    passed param a4 wrong\n");
947         if (!(globalVariable13_1 & 16)) printf("    passed param a5 wrong\n");
948         if (!(globalVariable13_1 & 32)) printf("    return value wrong\n");
949     }
950 }
951
952
953 /*
954  * Test #14 - replace function call
955  */
956 void func14_2()
957 {
958     globalVariable14_1 = 2;
959 }
960
961 void func14_3()
962 {
963     globalVariable14_2 = 1;
964 }
965
966 void func14_1()
967 {
968     kludge = 1; /* Here so that the following function call isn't the first
969                    instruction */
970
971     func14_2();
972     func14_3();
973
974     if (globalVariable14_1 == 1 && globalVariable14_2 == 0) {
975         printf("Passed test #14 (replace/remove function call)\n");
976         passedTest[14] = TRUE;
977     } else {
978         printf("**Failed test #14 (replace/remove function call)\n");
979         if (globalVariable14_1 != 1)
980             printf("    call to func14_2() was not replaced\n");
981         if (globalVariable14_2 != 0)
982             printf("    call to func14_3() was not removed\n");
983     }
984 }
985
986
987 /*
988  * Test #15 - setMutationsActive
989  */
990 void check15result(char *varname, int value, int expected,
991                    char *errstr, int *failed)
992 {
993     if (value != expected) {
994         if (!*failed)
995             printf("**failed test #15 (setMutationsActive)\n");
996         *failed = TRUE;
997
998         printf("    %s = %d %s\n", varname, value, errstr);
999     }           
1000 }
1001
1002
1003 void func15_2()
1004 {
1005   DUMMY_FN_BODY;
1006 }
1007
1008 void func15_3()
1009 {
1010     globalVariable15_3 = 100;
1011     /* increment a dummy variable to keep alpha code generator from assuming
1012        too many free registers on the call into func15_3. jkh 3/7/00 */
1013     globalVariable15_4++;
1014 }
1015
1016 void func15_4()
1017 {
1018     kludge = 1; /* Here so that the following function call isn't the first
1019                    instruction */
1020
1021     func15_3();
1022 }
1023
1024
1025 void func15_1()
1026 {
1027     int failed = FALSE;
1028
1029     func15_2();
1030     check15result("globalVariable15_1", globalVariable15_1, 1,
1031                   "after first call to instrumented function", &failed);
1032
1033 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
1034     /* Test a function that makes a system call (is a special case on Sparc) */
1035     access(".", R_OK);
1036     check15result("globalVariable15_2", globalVariable15_2, 2,
1037                   "after first call to instrumented function", &failed);
1038 #endif
1039
1040     func15_4();
1041     check15result("globalVariable15_3", globalVariable15_3, 1,
1042                   "after first call to instrumented function", &failed);
1043
1044     /***********************************************************/
1045
1046     stop_process();
1047
1048     func15_2();
1049     check15result("globalVariable15_1", globalVariable15_1, 1,
1050                   "after second call to instrumented function", &failed);
1051
1052 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
1053     access(".", R_OK);
1054     check15result("globalVariable15_2", globalVariable15_2, 2,
1055                   "after second call to instrumented function", &failed);
1056 #endif
1057
1058     func15_4();
1059     check15result("globalVariable15_3", globalVariable15_3, 100,
1060                   "after second call to instrumented function", &failed);
1061
1062     /***********************************************************/
1063
1064     stop_process();
1065
1066     func15_2();
1067     check15result("globalVariable15_1", globalVariable15_1, 2,
1068                   "after third call to instrumented function", &failed);
1069
1070 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
1071     access(".", R_OK);
1072     check15result("globalVariable15_2", globalVariable15_2, 4,
1073                   "after third call to instrumented function", &failed);
1074 #endif
1075
1076     func15_4();
1077     check15result("globalVariable15_3", globalVariable15_3, 101,
1078                   "after third call to instrumented function", &failed);
1079
1080     if (!failed) {
1081         printf("Passed test #15 (setMutationsActive)\n");
1082         passedTest[15] = TRUE;
1083     }
1084 }
1085
1086
1087 /*  
1088  * Test #16 - if-else
1089  *      Test if-then-else clauses
1090  */
1091
1092 void func16_2() { dprintf("func16_2 () called\n"); }
1093 void func16_3() { dprintf("func16_3 () called\n"); }
1094 void func16_4() { dprintf("func16_4 () called\n"); }
1095
1096 void func16_1()
1097 {
1098     int failed = FALSE;
1099
1100     func16_2();
1101     if (globalVariable16_1 != 1 || globalVariable16_2 != 0) {
1102         printf("**Failed test #16 (if-else)\n");
1103         if (globalVariable16_1 != 1)
1104             printf("    True clause of first if should have been executed but was not.\n");
1105         if (globalVariable16_2 != 0)
1106             printf("    False clause of first if should not have been executed but was.\n");
1107         failed = 1;
1108     }
1109
1110     func16_3();
1111     if (globalVariable16_3 != 0 || globalVariable16_4 != 1) {
1112         printf("**Failed test #16 (if-else)\n");
1113         if (globalVariable16_3 != 1)
1114             printf("    True clause of second if should not have been executed but was.\n");
1115         if (globalVariable16_4 != 0)
1116             printf("    False clause of second if should have been executed but was not.\n");
1117         failed = 1;
1118     }
1119
1120     func16_4();
1121     if ((globalVariable16_5 != 0 || globalVariable16_6 != 1) ||
1122         (globalVariable16_7 != 0 || globalVariable16_8 != 1) ||
1123         (globalVariable16_9 != 0 || globalVariable16_10 != 1)) {
1124             printf("    failed large if clauses tests.\n");
1125         failed = 1;
1126     }
1127
1128     if (!failed)
1129         printf("Passed test #16 (if-else)\n");
1130         passedTest[16] = TRUE;
1131 }
1132
1133
1134 /*
1135  * Test #17 - return values from func calls
1136  *      See test1.C for a detailed comment
1137  */
1138 void func17_1()
1139 {
1140     int ret17_1;
1141     int func17_2();
1142     void func17_3();
1143
1144     ret17_1 = func17_2();
1145     func17_3();
1146
1147     if ((ret17_1 != RET17_1) || 
1148         (globalVariable17_1 != RET17_2) ||
1149         (globalVariable17_2 != RAN17_1)) {
1150         printf("**Failed** test case #17 (return values from func calls)\n");
1151         if (ret17_1 != RET17_1) {
1152             printf("  return value was %d, not %d\n", ret17_1, RET17_1);
1153         }
1154         if (globalVariable17_1 != RET17_2) {
1155             printf("  return value was %d, not %d\n",
1156                 globalVariable17_1, RET17_2);
1157         }
1158         if (globalVariable17_2 != RAN17_1) {
1159             printf("  function call17_2 was not inserted\n");
1160         }
1161     } else {
1162         printf("Passed test #17 (return values from func calls)\n");
1163         passedTest[17] = TRUE;
1164     }
1165 }
1166
1167 int func17_2()
1168 {
1169     return RET17_1;
1170 }
1171
1172 int func17_4()
1173 {
1174     return RET17_2;
1175 }
1176
1177 void func17_3()
1178 {
1179     globalVariable17_1 = func17_4();
1180     return;
1181 }
1182
1183 /*
1184  * Test #18 - read/write a variable in the mutatee
1185  */
1186 void func18_1()
1187 {
1188     if (globalVariable18_1 == 17) {
1189         printf("Passed test #18 (read/write a variable in the mutatee)\n");
1190         passedTest[18] = TRUE;
1191     } else {
1192         printf("**Failed test #18 (read/write a variable in the mutatee)\n");
1193         if (globalVariable18_1 == 42)
1194             printf("    globalVariable18_1 still contains 42 (probably it was not written to)\n");
1195         else
1196             printf("    globalVariable18_1 contained %d, not 17 as expected\n",
1197                     globalVariable18_1);
1198     }
1199 }
1200
1201 /*
1202  * Test #19 - oneTimeCode
1203  */
1204 void func19_1()
1205 {
1206     stop_process();
1207
1208     if (globalVariable19_1 == MAGIC19_1) {
1209         printf("Passed test #19 (oneTimeCode)\n");
1210         passedTest[19] = TRUE;
1211     } else {
1212         printf("**Failed test #19 (oneTimeCode)\n");
1213         printf("    globalVariable19_1 contained %d, not %d as expected\n",
1214                 globalVariable19_1, MAGIC19_1);
1215     }
1216 }
1217
1218
1219 /*
1220  * Test #20 - instrumentation at arbitrary points
1221  */
1222
1223 int func20_3()
1224 {
1225     static int n = 1;
1226
1227     return n++;
1228 }
1229
1230
1231 volatile int tc = TEST20_C;
1232 volatile double td = TEST20_D;
1233 int test20_iter = 50;
1234
1235 int func20_2(int *int_val, double *double_val)
1236 {
1237     int i, ret = 1;
1238
1239     *int_val = tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
1240                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
1241                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
1242                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc
1243                ))))))))))))))))))))))))))))))))))))))));
1244
1245     *double_val = td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
1246                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
1247                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
1248                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+(td
1249                   ))))))))))))))))))))))))))))))))))))))));
1250
1251     for (i = 0; i < test20_iter; i++) {
1252         ret *= 3;
1253         if (i % 2 == 1) {
1254             ret *= 5;
1255         } else if (i < 10) {
1256             ret *= 7;
1257         } else if (i > 20) {
1258             ret *= 11;
1259         }
1260     }
1261
1262 /* The answer we expect from the above is: */
1263 #define TEST20_ANSWER 1088896211
1264
1265     return ret;
1266 }
1267
1268 void func20_1()
1269 {
1270 #if !defined(rs6000_ibm_aix4_1) && \
1271     !defined(alpha_dec_osf4_0)
1272
1273     printf("Skipped test #20 (instrument arbitrary points)\n");
1274     printf("\t- not implemented on this platform\n");
1275     passedTest[20] = TRUE;
1276 #else
1277     int ret;
1278     int int_val;
1279     double double_val;
1280
1281     ret = func20_2(&int_val, &double_val);
1282
1283     if (globalVariable20_1 == (TEST20_A * TEST20_TIMES) &&
1284         eq_doubles(globalVariable20_2, (TEST20_B * (double)TEST20_TIMES)) &&
1285         int_val == (TEST20_C * TEST20_TIMES) &&
1286         eq_doubles(double_val, (TEST20_D * (double)TEST20_TIMES)) &&
1287         ret == TEST20_ANSWER) {
1288         printf("Passed test #20 (instrument arbitrary points)\n");
1289         passedTest[20] = TRUE;
1290     } else {
1291         printf("**Failed test #20 (instrument arbitrary points)\n");
1292         if (globalVariable20_1 != (TEST20_A * TEST20_TIMES))
1293             printf("    globalVariable20_1 contained %d, not %d as expected\n",
1294                    globalVariable20_1, TEST20_A * TEST20_TIMES);
1295         if (!eq_doubles(globalVariable20_2, (TEST20_B * (double)TEST20_TIMES)))
1296             printf("    globalVariable20_2 contained %g, not %g as expected\n",
1297                    globalVariable20_2, TEST20_B * (double)TEST20_TIMES);
1298         if (int_val != (TEST20_C * TEST20_TIMES))
1299             printf("    int_val contained %d, not %d as expected\n",
1300                    int_val, TEST20_C * TEST20_TIMES);
1301         if (!eq_doubles(double_val, (TEST20_D * (double)TEST20_TIMES)))
1302             printf("    double_val contained %g, not %g as expected\n",
1303                    double_val, TEST20_D * (double)TEST20_TIMES);
1304         if (ret != TEST20_ANSWER)
1305             printf("    ret contained %d, not %d as expected\n",
1306                    ret, TEST20_ANSWER);
1307     }
1308 #endif
1309 }
1310
1311 /*
1312  * Test #21 - findFunction in module
1313  */
1314 void func21_1()
1315 {
1316      /* Nothing for the mutatee to do in this test (findFunction in module) */
1317 #if defined(sparc_sun_solaris2_4) \
1318  || defined(mips_sgi_irix6_4) \
1319  || defined(i386_unknown_solaris2_5) \
1320  || defined(i386_unknown_linux2_0) \
1321  || defined(alpha_dec_osf4_0)
1322      printf("Passed test #21 (findFunction in module)\n");
1323      passedTest[21] = TRUE;
1324 #else
1325     printf("Skipped test #21 (findFunction in module)\n");
1326     printf("\t- not implemented on this platform\n");
1327     passedTest[21] = TRUE;
1328 #endif
1329 }
1330
1331 /*
1332  * Test #22 - replace function
1333  *
1334  * These are defined in libtestA.so
1335  */
1336 extern void call22_5A(int);  
1337 extern void call22_6(int);
1338
1339 volatile int _unused;   /* move decl here to dump compiler warning - jkh */
1340
1341 void func22_1()
1342 {
1343 #if !defined(sparc_sun_solaris2_4) && \
1344     !defined(alpha_dec_osf4_0)
1345
1346     printf("Skipped test #22 (replace function)\n");
1347     printf("\t- not implemented on this platform\n");
1348     passedTest[22] = TRUE;
1349 #else
1350     /* libtestA.so should already be loaded (by the mutator), but we
1351        need to use the dl interface to get pointers to the functions
1352        it defines. */
1353     void (*call22_5)(int);
1354     void (*call22_6)(int);
1355
1356     void *handleA;
1357     char dlopenName[128];
1358 #if defined(sparc_sun_solaris2_4) 
1359     int dlopenMode = RTLD_NOW | RTLD_GLOBAL;
1360 #else
1361     int dlopenMode = RTLD_NOW;
1362 #endif
1363     _unused = sprintf(dlopenName, "./%s", libNameA);
1364     handleA = dlopen(dlopenName, dlopenMode);
1365     if (! handleA) {
1366          printf("**Failed test #22 (replaceFunction)\n");
1367          printf("  Mutatee couldn't get handle for %s\n", libNameA);
1368     }
1369
1370     call22_5 = (void(*)(int))dlsym(handleA, "call22_5");
1371     if (! call22_5) {
1372          printf("**Failed test #22 (replaceFunction)\n");
1373          printf("  Mutatee couldn't get handle for call22_5 in %s\n", libNameA);
1374     }
1375     call22_6 = (void(*)(int))dlsym(handleA, "call22_6");
1376     if (! call22_6) {
1377          printf("**Failed test #22 (replaceFunction)\n");
1378          printf("  Mutatee couldn't get handle for call22_6 in %s\n", libNameA);
1379     }
1380
1381     /* Call functions that have been replaced by the mutator.  The
1382        side effects of these calls (replaced, not replaced, or
1383        otherwise) are independent of each other. */
1384     call22_1(10);  /* replaced by call22_2 */
1385     if (globalVariable22_1 != 10 + MAGIC22_2) {
1386          printf("**Failed test #22 (replace function) (a.out -> a.out)\n");
1387          return;
1388     }
1389     call22_3(20);  /* replaced by call22_4 */
1390     if (globalVariable22_2 != 20 + MAGIC22_4) {
1391          printf("**Failed test #22 (replace function) (a.out -> shlib)\n");
1392          return;
1393     } 
1394     call22_5(30);  /* replaced by call22_5 (in libtestB) */
1395     if (globalVariable22_3 != 30 + MAGIC22_5B) {
1396          printf("globalVariable22_3 = %d\n", globalVariable22_3);
1397          printf("30 + MAGIC22_5B = %d\n", 30 + MAGIC22_5B);
1398          printf("**Failed test #22 (replace function) (shlib -> shlib)\n");
1399          return;
1400     } 
1401     call22_6(40);  /* replaced by call22_6 */
1402     if (globalVariable22_4 != 40 + MAGIC22_7) {
1403          printf("**Failed test #22 (replace function) (shlib -> a.out)\n");
1404          return;
1405     }
1406     printf("Passed test #22 (replace function)\n");
1407     passedTest[22] = TRUE;
1408 #endif
1409 }
1410
1411
1412 /*
1413  * Test #23 - local variables
1414  */
1415 int shadowVariable23_1 = 2300010;
1416 int shadowVariable23_2 = 2300020;
1417 int globalShadowVariable23_1 = (int)0xdeadbeef;
1418 int globalShadowVariable23_2 = (int)0xdeadbeef;
1419 int globalVariable23_1 = 2300000;
1420
1421 void verifyScalarValue23(char *name, int a, int value)
1422 {
1423     verifyScalarValue(name, a, value, 23, "local variables");
1424 }
1425
1426 void call23_2()
1427 {
1428     /* copy shadowed global variables to visible global variables to permit 
1429      *    checking their values
1430      */
1431     globalShadowVariable23_1 = shadowVariable23_1;
1432     globalShadowVariable23_2 = shadowVariable23_2;
1433 }
1434
1435 void call23_1()
1436 {
1437     int localVariable23_1 = 2300019;
1438     int shadowVariable23_1 = 2300011;
1439     int shadowVariable23_2 = 2300021;
1440
1441     call23_2();                 /* place to manipulate local variables */
1442
1443     passedTest[23] = TRUE;
1444
1445     /* snippet didn't update local variable */
1446     verifyScalarValue23("localVariable23_1", localVariable23_1, 2300001);
1447
1448     /* did snippet update shadow variable (in the global scope) */
1449     verifyScalarValue23("globalShadowVariable23_1", globalShadowVariable23_1,
1450         2300010);
1451
1452     /* did snippet correctly update shadow variable call23_2 */
1453     verifyScalarValue23("shadowVariable23_1", shadowVariable23_1, 2300012);
1454
1455     /* did snippet correctly update shadow variable via global 
1456        scope in call23_2 */
1457     verifyScalarValue23("shadowVariable23_2", shadowVariable23_2, 2300021);
1458
1459     /* did snippet correctly update shadow variable via global 
1460        scope in call23_2 */
1461     verifyScalarValue23("globalShadowVariable23_2", globalShadowVariable23_2, 
1462         2300023);
1463
1464     /* did snippet correctly read local variable in call23_2 */
1465     verifyScalarValue23("globalVariable23_1", globalVariable23_1, 2300001);
1466 }
1467
1468 void func23_1()
1469 {
1470 #if !defined(sparc_sun_solaris2_4) && \
1471     !defined(rs6000_ibm_aix4_1) && \
1472     !defined(alpha_dec_osf4_0) && \
1473     !defined(i386_unknown_linux2_0) && \
1474     !defined(i386_unknown_solaris2_5)
1475
1476     printf("Skipped test #23 (local variables)\n");
1477     printf("\t- not implemented on this platform\n");
1478     passedTest[23] = TRUE;
1479 #else
1480     call23_1();
1481
1482     if (passedTest[23]) printf("Passed test #23 (local variables)\n");
1483 #endif
1484 }
1485
1486 /*
1487  * Test #24 - arrary variables
1488  */
1489 int dummy;
1490 int foo;
1491
1492 int globalVariable24_1[100];
1493 int globalVariable24_2 = 53;
1494 int globalVariable24_3;
1495 int globalVariable24_4 = 83;
1496 int globalVariable24_5;
1497
1498 /* to hold values from local array */
1499 int globalVariable24_6;
1500 int globalVariable24_7;
1501
1502 /* for 2-d arrays - array is not square and we avoid using diagonal elements
1503  *    to make sure we test address computation
1504  */
1505 int globalVariable24_8[10][15];
1506 int globalVariable24_9;
1507
1508 void verifyValue24(char *name, int *a, int index, int value)
1509 {
1510     verifyValue(name, a, index, value, 24, "array variables");
1511 }
1512
1513 void verifyScalarValue24(char *name, int a, int value)
1514 {
1515     verifyScalarValue(name, a, value, 24, "array variables");
1516 }
1517
1518 void call24_2()
1519 {
1520 }
1521
1522 void call24_1() 
1523
1524 #ifdef sparc_sun_solaris2_4
1525     unsigned i=0; /* hack to prevent g++'s optimizer making func uninstr'uble */
1526 #else
1527     unsigned i;
1528 #endif
1529     int localVariable24_1[100];
1530
1531     for (i=0; i < 100; i++) localVariable24_1[i] = 2400000;
1532
1533     localVariable24_1[79] = 2400007;
1534     localVariable24_1[83] = 2400008;
1535
1536     call24_2();
1537
1538     verifyValue24("localVariable24_1", localVariable24_1, 1, 2400005);
1539     verifyValue24("localVariable24_1", localVariable24_1, 53, 2400006);
1540 }
1541
1542 void func24_1()
1543 {
1544 #if !defined(sparc_sun_solaris2_4) && \
1545     !defined(rs6000_ibm_aix4_1) && \
1546     !defined(alpha_dec_osf4_0) && \
1547     !defined(i386_unknown_linux2_0) && \
1548     !defined(i386_unknown_solaris2_5)
1549
1550     printf("Skipped test #24 (arrary variables)\n");
1551     printf("\t- not implemented on this platform\n");
1552     passedTest[24] = TRUE;
1553 #else
1554     int i, j;
1555
1556     passedTest[24] = TRUE;
1557
1558
1559     for (i=0; i < 100; i++) globalVariable24_1[i] = 2400000;
1560     globalVariable24_1[79] = 2400003;
1561     globalVariable24_1[83] = 2400004;
1562
1563     for (i=0; i < 10; i++) {
1564         for (j=0; j < 15; j++) {
1565             globalVariable24_8[i][j] = 2400010;
1566         }
1567     }
1568     globalVariable24_8[7][9] = 2400012;
1569
1570     /* inst code we put into this function:
1571      *  At Call:
1572      *     globalVariable24_1[1] = 2400001
1573      *     globalVariable24_1[globalVariable24_2] = 2400002
1574      *     globalVariable24_3 = globalVariable24_1[79]
1575      *     globalVariable24_5 = globalVariable24_1[globalVariable24_4]
1576      *     localVariable24_1[1] = 2400001
1577      *     localVariable24_1[globalVariable24_2] = 2400002
1578      *     globalVariable24_8[2][3] = 2400011
1579      *     globalVariable24_6 = localVariable24_1[79]
1580      *     globalVariable24_7 = localVariable24_1[globalVariable24_4]
1581      */
1582     call24_1();
1583
1584     for (i=0; i < 100; i++) {
1585         if (i == 1) {
1586             /* 1st element should be modified by the snippet (constant index) */
1587             verifyValue24("globalVariable24_1", globalVariable24_1, 1, 2400001);
1588         } else if (i == 53) {
1589             /* 53rd element should be modified by the snippet (variable index) */
1590             verifyValue24("globalVariable24_1", globalVariable24_1, 53, 2400002);
1591         } else if (i == 79) {
1592             /* 79th element was modified by us  */
1593             verifyValue24("globalVariable24_1", globalVariable24_1, 79, 2400003);
1594         } else if (i == 83) {
1595             /* 83rd element was modified by us  */
1596             verifyValue24("globalVariable24_1", globalVariable24_1, 83, 2400004);
1597         } else if (globalVariable24_1[i] != 2400000) {
1598             /* rest should still be the original value */
1599             verifyValue24("globalVariable24_1", globalVariable24_1, i, 2400000);
1600         }
1601     }
1602
1603     verifyScalarValue24("globalVariable24_3", globalVariable24_3, 2400003);
1604     verifyScalarValue24("globalVariable24_5", globalVariable24_5, 2400004);
1605
1606     /* now for the two elements read from the local variable */
1607     verifyScalarValue24("globalVariable24_6", globalVariable24_6, 2400007);
1608     verifyScalarValue24("globalVariable24_7", globalVariable24_7, 2400008);
1609
1610     /* verify 2-d element use */
1611     verifyScalarValue24("globalVariable24_8[2][3]", globalVariable24_8[2][3], 
1612          2400011);
1613     verifyScalarValue24("globalVariable24_9", globalVariable24_9, 2400012);
1614
1615     if (passedTest[24]) printf("Passed test #24 (array variables)\n");
1616 #endif
1617 }
1618
1619 /*
1620  * Test #25 - unary operators
1621  */
1622 int globalVariable25_1;
1623 int *globalVariable25_2;        /* used to hold addres of globalVariable25_1 */
1624 int globalVariable25_3;
1625 int globalVariable25_4;
1626 int globalVariable25_5;
1627 int globalVariable25_6;
1628 int globalVariable25_7;
1629
1630 void call25_1() 
1631
1632   DUMMY_FN_BODY;
1633 }
1634
1635 void func25_1()
1636 {
1637 #if defined(mips_sgi_irix6_4)
1638     printf("Skipped test #25 (unary operators)\n");
1639     printf("\t- not implemented on this platform\n");
1640     passedTest[25] = TRUE;
1641 #else
1642
1643     passedTest[25] = TRUE;
1644
1645     globalVariable25_1 = 25000001;
1646     globalVariable25_2 = (int *) 25000002;
1647     globalVariable25_3 = 25000003;
1648     globalVariable25_4 = 25000004;
1649     globalVariable25_5 = 25000005;
1650     globalVariable25_6 = -25000006;
1651     globalVariable25_7 = 25000007;
1652
1653     /* inst code we put into this function:
1654      *  At Entry:
1655      *     globalVariable25_2 = &globalVariable25_1
1656      *     globalVariable25_3 = *globalVariable25_2
1657      *     globalVariable25_5 = -globalVariable25_4
1658      *     globalVariable25_7 = -globalVariable25_6
1659      */
1660
1661     call25_1();
1662
1663     if ((int *) globalVariable25_2 != &globalVariable25_1) {
1664         if (passedTest[25]) printf("**Failed** test #25 (unary operators)\n");
1665         passedTest[25] = FALSE;
1666         printf("    globalVariable25_2 = %p, not %p\n", 
1667             globalVariable25_2, (void *) &globalVariable25_1);
1668     }
1669
1670     if (globalVariable25_3 != globalVariable25_1) {
1671         if (passedTest[25]) printf("**Failed** test #25 (unary operators)\n");
1672         passedTest[25] = FALSE;
1673         printf("    globalVariable25_3 = %d, not %d\n", 
1674             globalVariable25_3, globalVariable25_1);
1675     }
1676
1677     if (globalVariable25_5 != -globalVariable25_4) {
1678         if (passedTest[25]) printf("**Failed** test #25 (unary operators)\n");
1679         passedTest[25] = FALSE;
1680         printf("    globalVariable25_5 = %d, not %d\n", 
1681             globalVariable25_5, -globalVariable25_4);
1682     }
1683
1684     if (globalVariable25_7 != -globalVariable25_6) {
1685         if (passedTest[25]) printf("**Failed** test #25 (unary operators)\n");
1686         passedTest[25] = FALSE;
1687         printf("    globalVariable25_7 = %d, not %d\n", 
1688             globalVariable25_7, -globalVariable25_6);
1689     }
1690
1691     if (passedTest[25]) printf("Passed test #25 (unary operators)\n");
1692 #endif
1693 }
1694
1695 /*
1696  * Test #26 - field operators
1697  */
1698
1699 struct struct26_1 {
1700     int field1;
1701     int field2;
1702 };
1703
1704 struct struct26_2 {
1705     int field1;
1706     int field2;
1707     int field3[10];
1708     struct struct26_1 field4;
1709 };
1710
1711 struct struct26_2 globalVariable26_1;
1712 int globalVariable26_2 = 26000000;
1713 int globalVariable26_3 = 26000000;
1714 int globalVariable26_4 = 26000000;
1715 int globalVariable26_5 = 26000000;
1716 int globalVariable26_6 = 26000000;
1717 int globalVariable26_7 = 26000000;
1718
1719 int globalVariable26_8 = 26000000;
1720 int globalVariable26_9 = 26000000;
1721 int globalVariable26_10 = 26000000;
1722 int globalVariable26_11 = 26000000;
1723 int globalVariable26_12 = 26000000;
1724 int globalVariable26_13 = 26000000;
1725
1726 void verifyScalarValue26(char *name, int a, int value)
1727 {
1728     verifyScalarValue(name, a, value, 26, "field operators");
1729 }
1730
1731 void call26_2()
1732 {
1733 }
1734
1735 void call26_1()
1736 {
1737     int i;
1738     struct struct26_2 localVariable26_1;
1739
1740     localVariable26_1.field1 = 26002001;
1741     localVariable26_1.field2 = 26002002;
1742     for (i=0; i < 10; i++) localVariable26_1.field3[i] = 26002003 + i;
1743     localVariable26_1.field4.field1 = 26002013;
1744     localVariable26_1.field4.field2 = 26002014;
1745
1746     /* check local variables at this point (since we known locals are still
1747        on the stack here. */
1748     call26_2();
1749
1750 }
1751
1752 void func26_1()
1753 {
1754 #if !defined(sparc_sun_solaris2_4) && \
1755     !defined(rs6000_ibm_aix4_1) && \
1756     !defined(alpha_dec_osf4_0) && \
1757     !defined(i386_unknown_linux2_0) && \
1758     !defined(i386_unknown_solaris2_5)
1759
1760     printf("Skipped test #26 (struct elements)\n");
1761     printf("\t- not implemented on this platform\n");
1762     passedTest[26] = TRUE;
1763 #else
1764     int i;
1765
1766     passedTest[26] = TRUE;
1767
1768     globalVariable26_1.field1 = 26001001;
1769     globalVariable26_1.field2 = 26001002;
1770     for (i=0; i < 10; i++) globalVariable26_1.field3[i] = 26001003 + i;
1771     globalVariable26_1.field4.field1 = 26000013;
1772     globalVariable26_1.field4.field2 = 26000014;
1773
1774     call26_1();
1775
1776     verifyScalarValue26("globalVariable26_2", globalVariable26_2, 26001001);
1777     verifyScalarValue26("globalVariable26_3", globalVariable26_3, 26001002);
1778     verifyScalarValue26("globalVariable26_4", globalVariable26_4, 26001003);
1779     verifyScalarValue26("globalVariable26_5", globalVariable26_5, 26001003+5);
1780     verifyScalarValue26("globalVariable26_6", globalVariable26_6, 26000013);
1781     verifyScalarValue26("globalVariable26_7", globalVariable26_7, 26000014);
1782
1783     /* local variables */
1784     verifyScalarValue26("globalVariable26_8", globalVariable26_8, 26002001);
1785     verifyScalarValue26("globalVariable26_9", globalVariable26_9, 26002002);
1786     verifyScalarValue26("globalVariable26_10", globalVariable26_10, 26002003);
1787     verifyScalarValue26("globalVariable26_11", globalVariable26_11, 26002003+5);
1788     verifyScalarValue26("globalVariable26_12", globalVariable26_12, 26002013);
1789     verifyScalarValue26("globalVariable26_13", globalVariable26_13, 26002014);
1790
1791     if (passedTest[26]) printf("Passed test #26 (field operators)\n");
1792 #endif
1793 }
1794
1795 /*
1796  * Test #27 - type compatibility
1797  */
1798
1799 typedef struct {
1800     /* void *field27_11; */
1801     int field27_11;
1802     float field27_12;
1803 } type27_1;
1804
1805 typedef struct {
1806     /* void *field27_21; */
1807     int field27_21;
1808     float field27_22;
1809 } type27_2;
1810
1811 typedef struct {
1812     int field3[10];
1813     struct struct26_2 field4;
1814 } type27_3;
1815
1816 typedef struct {
1817     int field3[10];
1818     struct struct26_2 field4;
1819 } type27_4;
1820
1821 int globalVariable27_1;
1822
1823 /* need this variables or some compilers (AIX xlc) will removed unused
1824    typedefs - jkh 10/13/99 */
1825 type27_1 dummy1;
1826 type27_2 dummy2;
1827 type27_3 dummy3;
1828 type27_4 dummy4;
1829
1830 int globalVariable27_5[10];
1831 int globalVariable27_6[10];
1832 float globalVariable27_7[10];
1833 float globalVariable27_8[12];
1834
1835 void func27_1()
1836 {
1837 #if !defined(sparc_sun_solaris2_4) && \
1838     !defined(rs6000_ibm_aix4_1) && \
1839     !defined(alpha_dec_osf4_0) && \
1840     !defined(i386_unknown_linux2_0) && \
1841     !defined(i386_unknown_solaris2_5)
1842
1843     printf("Skipped test #27 (type compatibility)\n");
1844     printf("\t- not implemented on this platform\n");
1845     passedTest[27] = TRUE;
1846 #else
1847     passedTest[27] = (globalVariable27_1 == 1);
1848
1849     if (passedTest[27]) printf("Passed test #27 (type compatibility)\n");
1850 #endif
1851 }
1852
1853 /*
1854  * Test #28 - field operators
1855  */
1856
1857 struct struct28_1 {
1858     int field1;
1859     int field2;
1860 };
1861
1862 struct struct28_2 {
1863     int field1;
1864     int field2;
1865     int field3[10];
1866     struct struct28_1 field4;
1867 };
1868
1869 char globalVariable28_1[sizeof(struct struct28_2)];
1870 struct struct28_2 *temp;
1871 int globalVariable28_2 = 28000000;
1872 int globalVariable28_3 = 28000000;
1873 int globalVariable28_4 = 28000000;
1874 int globalVariable28_5 = 28000000;
1875 int globalVariable28_6 = 28000000;
1876 int globalVariable28_7 = 28000000;
1877
1878 void verifyScalarValue28(char *name, int a, int value)
1879 {
1880     verifyScalarValue(name, a, value, 28, "user defined fields");
1881 }
1882
1883 void call28_1()
1884 {
1885     int i = 42;
1886
1887     int j = i;
1888
1889     for (j=0; j < 400; j++);
1890 }
1891
1892 int globalVariable29_1;
1893
1894 void func28_1()
1895 {
1896     int i;
1897
1898     passedTest[28] = TRUE;
1899
1900     
1901     temp = (struct struct28_2 *) globalVariable28_1;
1902
1903     temp->field1 = 28001001;
1904     temp->field2 = 28001002;
1905     for (i=0; i < 10; i++) temp->field3[i] = 28001003 + i;
1906     temp->field4.field1 = 28000013;
1907     temp->field4.field2 = 28000014;
1908
1909     call28_1();
1910
1911     verifyScalarValue28("globalVariable28_2", globalVariable28_2, 28001001);
1912     verifyScalarValue28("globalVariable28_3", globalVariable28_3, 28001002);
1913     verifyScalarValue28("globalVariable28_4", globalVariable28_4, 28001003);
1914     verifyScalarValue28("globalVariable28_5", globalVariable28_5, 28001003+5);
1915     verifyScalarValue28("globalVariable28_6", globalVariable28_6, 28000013);
1916     verifyScalarValue28("globalVariable28_7", globalVariable28_7, 28000014);
1917
1918     if (passedTest[28]) printf("Passed test #28 (user defined fields)\n");
1919 }
1920
1921 int func29_1()
1922 {
1923     passedTest[29] = (globalVariable29_1 == 1);
1924
1925     if (passedTest[29]) printf("Passed test #29 (BPatch_srcObj class)\n");
1926
1927     return 0;
1928 }
1929
1930 void func30_2()
1931 {
1932     DUMMY_FN_BODY;
1933 }
1934
1935 /* variables to keep the base addr and last addr of call30_1 */
1936 unsigned globalVariable30_8 = 0;
1937 unsigned globalVariable30_9 = 0;
1938 int func30_1()
1939 {
1940
1941 #if defined(sparc_sun_solaris2_4) || \
1942     defined(i386_unknown_solaris2_5) || \
1943     defined(i386_unknown_linux2_0) || \
1944     defined(rs6000_ibm_aix4_1) || \
1945     defined(alpha_dec_osf4_0)
1946
1947     func30_2();
1948
1949     passedTest[30] = !globalVariable30_3 ||
1950 #if defined(rs6000_ibm_aix4_1)
1951                      ((globalVariable30_8 <= globalVariable30_3) &&
1952 #else
1953                      ((globalVariable30_2 <= globalVariable30_3) &&
1954 #endif
1955                       (globalVariable30_3 <= globalVariable30_9));
1956     if (!passedTest[30]){ 
1957         printf("**Failed** test #30 (line information) in %s[%d]\n", __FILE__, __LINE__ );
1958         return 0;
1959     }
1960
1961     passedTest[30] = !globalVariable30_4 ||
1962 #if defined(rs6000_ibm_aix4_1)
1963                      ((globalVariable30_8 <= globalVariable30_4) &&
1964 #else
1965                      ((globalVariable30_2 <= globalVariable30_4) &&
1966 #endif
1967                       (globalVariable30_4 <= globalVariable30_9));
1968     if (!passedTest[30]){
1969         printf("**Failed** test #30 (line information) in %s[%d]\n", __FILE__, __LINE__ );
1970         return 0;
1971     }
1972
1973     passedTest[30] = !globalVariable30_5 ||
1974 #if defined(rs6000_ibm_aix4_1)
1975                      ((globalVariable30_8 <= globalVariable30_5) &&
1976 #else
1977                      ((globalVariable30_2 <= globalVariable30_5) &&
1978 #endif
1979                       (globalVariable30_5 <= globalVariable30_9));
1980     if (!passedTest[30]){ 
1981         printf("**Failed** test #30 (line information) in %s[%d]\n", __FILE__, __LINE__ );
1982         return 0;
1983     }
1984    
1985     passedTest[30] = !globalVariable30_6 ||
1986                      (globalVariable30_1 == globalVariable30_6);
1987     if (!passedTest[30]){ 
1988         printf("**Failed** test #30 (line information) in %s[%d]\n", __FILE__, __LINE__ );
1989         return 0;
1990     }
1991
1992     printf("Passed test #30 (line information)\n");
1993
1994 #else
1995     printf("Skipped test #30 (line information)\n");
1996     printf("\t- not implemented on this platform\n");
1997     passedTest[30] = TRUE;
1998 #endif
1999     return 1;
2000 }
2001
2002 /****************************************************************************/
2003 /****************************************************************************/
2004 /****************************************************************************/
2005
2006 void func31_2()
2007 {
2008   globalVariable31_2 = 1;
2009 }
2010
2011 void func31_3()
2012 {
2013   globalVariable31_3 = 1;
2014 }
2015
2016 void func31_4( int value )
2017 {
2018   if( value == 0 )
2019     {
2020       printf( "func_31_4 called with value = 0 !\n" );
2021     }
2022
2023   globalVariable31_4 += value;
2024 }
2025
2026 int func31_1()
2027 {
2028 #if defined(alpha_dec_osf4_0)
2029     printf( "Skipped test #31 (non-recursive base tramp guard)\n" );
2030     printf( "\t- not implemented on this platform\n" );
2031     passedTest[ 31 ] = TRUE;
2032
2033     return 1;
2034 #else
2035   globalVariable31_1 = 0;
2036   globalVariable31_2 = 0;
2037   globalVariable31_3 = 0;
2038   globalVariable31_4 = 0;
2039
2040   func31_2();
2041
2042   passedTest[ 31 ] = ( globalVariable31_3 == 1 );
2043   if( ! passedTest[ 31 ] )
2044     {
2045       printf( "**Failed** test #31 (non-recursive base tramp guard)\n" );
2046       printf( "    globalVariable31_3 = %d, should be 1 (no instrumentation got executed?).\n",
2047               globalVariable31_3 );
2048       return 0;
2049     }
2050
2051   passedTest[ 31 ] = ( globalVariable31_4 == 0 );
2052   if( ! passedTest[ 31 ] )
2053     {
2054       printf( "**Failed** test #31 (non-recursive base tramp guard)\n" );
2055       printf( "    globalVariable31_4 = %d, should be 0.\n",
2056               globalVariable31_4 );
2057       switch( globalVariable31_4 )
2058         {
2059         case 0: printf( "    Recursive guard works fine.\n" ); break;
2060         case 1: printf( "    Pre-instr recursive guard does not work.\n" ); break;
2061         case 2: printf( "    Post-instr recursive guard does not work.\n" ); break;
2062         case 3: printf( "    None of the recursive guards work.\n" ); break;
2063         default: printf( "    Something is really wrong.\n" ); break;
2064         }
2065       return 0;
2066     }
2067
2068   passedTest[ 31 ] = TRUE;
2069   printf( "Passed test #31 (non-recursive base tramp guard)\n" );
2070
2071   return 1;
2072 #endif
2073 }
2074
2075 /****************************************************************************/
2076 /****************************************************************************/
2077 /****************************************************************************/
2078
2079 void func32_2()
2080 {
2081   globalVariable32_2 = 1;
2082 }
2083
2084 void func32_3()
2085 {
2086   globalVariable32_3 = 1;
2087 }
2088
2089 void func32_4( int value )
2090 {
2091   if( value == 0 )
2092     {
2093       printf( "func_32_4 called with value = 0 !\n" );
2094     }
2095
2096   globalVariable32_4 += value;
2097 }
2098
2099 int func32_1()
2100 {
2101   globalVariable32_1 = 0;
2102   globalVariable32_2 = 0;
2103   globalVariable32_3 = 0;
2104   globalVariable32_4 = 0;
2105
2106   func32_2();
2107
2108   passedTest[ 32 ] = ( globalVariable32_3 == 1 );
2109   if( ! passedTest[ 32 ] )
2110     {
2111       printf( "**Failed** test #32 (non-recursive base tramp guard)\n" );
2112       printf( "    globalVariable32_3 = %d, should be 1 (no instrumentation got executed?).\n",
2113               globalVariable32_3 );
2114       return 0;
2115     }
2116
2117   passedTest[ 32 ] = ( globalVariable32_4 == 3 );
2118   if( ! passedTest[ 32 ] )
2119     {
2120       printf( "**Failed** test #32 (non-recursive base tramp guard)\n" );
2121       printf( "    globalVariable32_4 = %d, should be 3.\n",
2122               globalVariable32_4 );
2123       switch( globalVariable32_4 )
2124         {
2125         case 0: printf( "    Recursive guard works fine.\n" ); break;
2126         case 1: printf( "    Pre-instr recursive guard does not work.\n" ); break;
2127         case 2: printf( "    Post-instr recursive guard does not work.\n" ); break;
2128         case 3: printf( "    None of the recursive guards work.\n" ); break;
2129         default: printf( "    Something is really wrong.\n" ); break;
2130         }
2131       return 0;
2132     }
2133
2134   passedTest[ 32 ] = TRUE;
2135   printf( "Passed test #32 (recursive base tramp guard)\n" );
2136
2137   return 1;
2138 }
2139
2140
2141 #ifdef __cplusplus
2142
2143 void cpp_test_util::call_cpp(int test)
2144 {
2145    passedTest[test] = TRUE;
2146
2147    switch (test) {
2148
2149     case 33 : {
2150                  cout << "Passed test #33 (C++ argument pass)" << endl;
2151                  break;
2152     }
2153
2154     case 34 : {
2155                  cout << "Passed test #34 (overload function)" << endl;
2156                  break;
2157     }
2158     
2159     case 35 : {
2160                  cout << "Passed test #35 (overload operator)" << endl;
2161                  break;
2162     }
2163
2164     case 36 : {
2165                  cout << "Passed test #36 (static member)" << endl;
2166                  break;
2167     }
2168     
2169     case 37 : {
2170                  cout << "Passed test #37 (namespace)" << endl;
2171                  break;
2172     }
2173
2174     case 39 : {
2175                  cout << "Passed test #39 (template)" << endl;
2176                  break;
2177     }
2178
2179     case 40 : {
2180                  cout << "Passed test #40 (declaration)" << endl;
2181                  break;
2182     }
2183
2184     case 41 : {
2185                  cout << "Passed test #41 (derivation)" << endl;
2186                  break;
2187     }
2188
2189     case 44 : {
2190                  cout << "Passed test #44 (C++ Member function)" << endl;
2191                  break;
2192     }
2193
2194     default : {
2195                  cerr << "\tInvalid test "<< test <<" requested" << endl;
2196                  cerr << "\tThis invalid test# is most likely caused by the C++ class member function argument passing" << endl;
2197                  break;
2198     }
2199
2200   }
2201 }
2202
2203
2204 void arg_test::func_cpp()
2205 {
2206   int test = 33;
2207   int arg2 = 33;
2208
2209   call_cpp(test, arg2);
2210 }
2211
2212 void arg_test::arg_pass(int test)
2213 {
2214    if (test != 33) {
2215     cerr << "**Failed** test #33 (C++ argument pass)" << endl;
2216     cerr << "    Pass in an incorrect parameter value" << endl;
2217     return;
2218    }
2219    cpp_test_util::call_cpp(test);
2220 }
2221
2222 void arg_test::dummy()
2223 {
2224   DUMMY_FN_BODY;
2225 }
2226
2227 void arg_test::call_cpp(const int arg1, int & arg2, int arg3)
2228 {
2229    const int m = 8;
2230    int n = 6;
2231    int & reference = n;
2232
2233    dummy(); // place to change the value of arg3 from CPP_DEFLT_ARG to 33
2234
2235    if ( 33 != arg3 ) {
2236      cerr << "**Failed** test #33 (C++ argument pass)" << endl;
2237      cerr << "    Default argument value is not changed " << endl;
2238    }
2239
2240    if ( arg1 == arg2 )  arg2 = CPP_DEFLT_ARG;
2241 }
2242
2243 void overload_func_test::func_cpp()
2244 {
2245    call_cpp("test overload function");
2246
2247    call_cpp(34);
2248
2249    call_cpp(34, 34.0);
2250 }
2251
2252
2253 void overload_func_test::call_cpp(char * arg1)
2254 {
2255   DUMMY_FN_BODY;
2256 }
2257
2258
2259 void overload_func_test::call_cpp(int arg1)
2260 {
2261   DUMMY_FN_BODY;
2262 }
2263
2264
2265 void overload_func_test::call_cpp(int arg1, float arg2)
2266 {
2267   DUMMY_FN_BODY;
2268 }
2269
2270 void overload_op_test::func_cpp()
2271 {
2272    overload_op_test test;
2273    ++test;
2274 }
2275
2276 void overload_op_test_call_cpp(int arg)
2277 {
2278    if ( arg == 35 ) {
2279      passedTest[arg] = TRUE;
2280      cout << "Passed test #35 (overload operator)" << endl;
2281    } else {
2282      cerr << "**Failed** test #35 (overload operator)" << endl;
2283      cerr << "    Overload operator++ return wrong value " << endl;
2284    }
2285 }
2286
2287 int overload_op_test::operator++()
2288 {
2289   return (cpp_test_util::CPP_TEST_UTIL_VAR);
2290 }
2291 void static_test_call_cpp(int test)
2292 {
2293    passedTest[test] = TRUE;
2294    cout << "Passed test #36 (static member)" << endl;
2295 }
2296
2297 int static_test::count = 0;
2298
2299 void static_test::func_cpp()
2300 {
2301    static_test obj1, obj2;
2302
2303    if ((obj1.call_cpp()+1) != obj2.call_cpp()) {
2304       cerr << "**Failed** test #36 (static member)" << endl;
2305       cerr << "    C++ objects of the same class have different static members " << endl;
2306    }
2307 }
2308
2309 static int local_file_var = 35;
2310
2311 void namespace_test::func_cpp()
2312 {
2313   int local_fn_var = local_file_var;
2314
2315   class_variable = local_fn_var;
2316
2317   if ( 1024 != ::CPP_DEFLT_ARG)
2318     cout << "::CPP_DEFLT_ARG init value wrong" <<endl;
2319   if ( 0 != cpp_test_util::CPP_TEST_UTIL_VAR )
2320     cout <<"cpp_test_util::CPP_TEST_UTIL_VAR int value wrong"<<endl;
2321 }
2322
2323
2324 void sample_exception::response()
2325 {
2326    DUMMY_FN_BODY;
2327 }
2328
2329
2330 void exception_test_call_cpp(int arg)
2331 {
2332    if ( arg == 38 ) {
2333       passedTest[arg] = TRUE;
2334       cout << "Passed test #38 (exception)" << endl;
2335    } else {
2336       cerr << "**Failed** test #38 (exception)" << endl;
2337    }
2338 }
2339
2340
2341 void exception_test::call_cpp()
2342 {
2343     throw sample_exception();
2344 }
2345
2346
2347 void exception_test::func_cpp()
2348 {
2349    try {
2350           int testno = 38;
2351           call_cpp();
2352    }
2353    catch ( sample_exception & ex) {
2354      ex.response();
2355    }
2356    catch ( ... ) {
2357      cerr << "**Failed** test #38 (exception)" << endl;
2358      cerr << "    Does not catch appropriate exception" << endl;
2359      throw;
2360    }
2361 }
2362
2363 #ifdef rs6000_ibm_aix4_1
2364 // xlC's static libC has strangely undefined symbols, so just fake them ...
2365 int SOMClassClassData;
2366 int SOMObjectClassData;
2367 #else
2368 // xlC also doesn't like these, so just skip them ...
2369 template class sample_template <int>;
2370 template class sample_template <double>;
2371 #endif
2372
2373 template <class T> T sample_template <T>::content()
2374 {
2375    T  ret = item;
2376    return (ret);
2377 }
2378
2379 void template_test::func_cpp()
2380 {
2381   int int39 = 39;
2382   char char39 = 'c';
2383   sample_template <int> item39_1(int39);
2384   sample_template <char> item39_2(char39);
2385  
2386   item39_1.content();
2387   item39_2.content();
2388 }
2389
2390 void template_test_call_cpp(int test)
2391 {
2392    passedTest[test] = TRUE;
2393    cout << "Passed test #39 (template)" << endl;
2394 }
2395
2396 void decl_test::func_cpp()
2397 {
2398    int CPP_DEFLT_ARG = 40;
2399
2400    if ( 40 != CPP_DEFLT_ARG )
2401      cout <<"CPP_DEFLT_ARG init value wrong"<<endl;
2402    if ( 1024 != ::CPP_DEFLT_ARG )
2403      cout <<"::CPP_DEFLT_ARG init value wrong"<<endl;
2404    if ( 0 != cpp_test_util::CPP_TEST_UTIL_VAR )
2405      cout <<"cpp_test_util::CPP_TEST_UTIL_VAR int value wrong"<<endl;
2406 }
2407
2408 void decl_test::call_cpp(int test)
2409 {
2410    if (test != 40) {
2411        cerr << "**Failed** test #40 (C++ argument pass)" << endl;
2412        cerr << "    Pass in an incorrect parameter value" << endl;
2413        return;
2414    }
2415    cpp_test_util::CPP_TEST_UTIL_VAR = ::CPP_DEFLT_ARG;
2416    cpp_test_util::call_cpp(test);
2417 }
2418
2419 void derivation_test::func_cpp()
2420 {
2421   DUMMY_FN_BODY;
2422 }
2423
2424 void stdlib_test1::func_cpp()
2425 {
2426 #if defined(sparc_sun_solaris2_4) \
2427  || defined(mips_sgi_irix6_4) \
2428  || defined(i386_unknown_solaris2_5) \
2429  || defined(i386_unknown_linux2_0) \
2430  || defined(alpha_dec_osf4_0)
2431      cout << "Passed test #42 (find standard C++ library)" << endl;
2432      passedTest[42] = TRUE;
2433 #else
2434     cout << "Skipped test #42 (find standard C++ library)" << endl;
2435     cout << "\t- not implemented on this platform" << endl;
2436     passedTest[42] = TRUE;
2437 #endif
2438
2439 }
2440
2441 void stdlib_test2::call_cpp()
2442 {
2443    DUMMY_FN_BODY;
2444 }
2445
2446 void stdlib_test2::func_cpp()
2447 {
2448 #if defined(sparc_sun_solaris2_4) \
2449  || defined(alpha_dec_osf4_0)
2450     cout<<"Passed test #43 (replace function in standard C++ library)"<<endl;
2451     passedTest[43] = TRUE;
2452 #else
2453     cout<<"Skipped test #43 (replace function in standard C++ library)"<<endl;
2454     cout<<"\t- not implemented on this platform"<<endl;
2455     passedTest[43] = TRUE;
2456 #endif
2457
2458 }
2459
2460
2461 int func_test::func2_cpp() const
2462 {
2463     return CPP_TEST_UTIL_VAR;
2464 }
2465
2466
2467 void func_test::func_cpp()
2468 {
2469    int int44 = func2_cpp();
2470    call_cpp(int44);
2471 }
2472
2473 #endif
2474
2475
2476 /****************************************************************************/
2477 /****************************************************************************/
2478 /****************************************************************************/
2479
2480 /* "replaceFunctionCall()" on Irix usually requires that the new
2481    callee have a GOT entry.  This dummy function forces GOT entries to
2482    be created for these functions. */
2483 #if defined(mips_sgi_irix6_4)
2484 void dummy_force_got_entries()
2485 {
2486     call14_1();
2487     call15_3();
2488 }
2489 #endif
2490
2491 #ifdef i386_unknown_nt4_0
2492 #define USAGE "Usage: test1 [-attach] [-verbose]"
2493 #else
2494 #define USAGE "Usage: test1 [-attach <fd>] [-verbose]"
2495 #endif
2496
2497 int main(int iargc, char *argv[])
2498 {                                       /* despite different conventions */
2499     unsigned argc=(unsigned)iargc;      /* make argc consistently unsigned */
2500     unsigned int i, j;
2501     unsigned int testsFailed = 0;
2502     int useAttach = FALSE;
2503 #ifndef i386_unknown_nt4_0
2504     int pfd;
2505 #endif
2506  
2507     for (j=0; j <= MAX_TEST; j++) {
2508         if (j <= 32) {
2509            passedTest[j] = FALSE;
2510            if (!useAttach) runTest[j] = TRUE;
2511         } else {
2512 #ifndef __cplusplus
2513                  passedTest[j] = TRUE;
2514                  runTest[j] = FALSE;
2515 #else
2516                  passedTest[j] = FALSE;
2517                  if (!useAttach) runTest[j] = TRUE;
2518 #endif
2519         }
2520     }
2521
2522     for (i=1; i < argc; i++) {
2523         if (!strcmp(argv[i], "-verbose")) {
2524             debugPrint = TRUE;
2525         } else if (!strcmp(argv[i], "-attach")) {
2526             useAttach = TRUE;
2527 #ifndef i386_unknown_nt4_0
2528             if (++i >= argc) {
2529                 fprintf(stderr, "%s\n", USAGE);
2530                 exit(-1);
2531             }
2532             pfd = atoi(argv[i]);
2533 #endif
2534         } else if (!strcmp(argv[i], "-run")) {
2535             runAllTests = FALSE;
2536             for (j=0; j <= MAX_TEST; j++) runTest[j] = FALSE;
2537             for (j=i+1; j < argc; j++) {
2538                 unsigned int testId;
2539                 if ((testId = atoi(argv[j]))) {
2540                     if ((testId > 0) && (testId <= MAX_TEST)) {
2541                         runTest[testId] = TRUE;
2542                     } else {
2543                         printf("invalid test %d requested\n", testId);
2544                         exit(-1);
2545                     }
2546                 } else {
2547                     /* end of test list */
2548                     break;
2549                 }
2550             }
2551             i=j-1;
2552         } else {
2553             fprintf(stderr, "%s\n", USAGE);
2554             exit(-1);
2555         }
2556     }
2557
2558     dprintf("Mutatee %s running (%s).\n", argv[0], 
2559                 mutateeCplusplus ? "C++" : "C");
2560
2561     if (useAttach) {
2562 #ifndef i386_unknown_nt4_0
2563         char ch = 'T';
2564         if (write(pfd, &ch, sizeof(char)) != sizeof(char)) {
2565             fprintf(stderr, "*ERROR*: Writing to pipe\n");
2566             exit(-1);
2567         }
2568         close(pfd);
2569 #endif
2570         printf("Waiting for mutator to attach...\n");
2571         while (!checkIfAttached()) ;
2572         printf("Mutator attached.  Mutatee continuing.\n");
2573     }
2574
2575     if (runTest[1]) func1_1();
2576     if (runTest[2]) func2_1();
2577     if (runTest[3]) func3_1();
2578     if (runTest[4]) func4_1();
2579     if (runTest[5]) func5_1();
2580     if (runTest[6]) func6_1();
2581     if (runTest[7]) func7_1();
2582     if (runTest[8]) func8_1(1,2,3,4,5,6,7,8,9,10);
2583     if (runTest[9]) func9_1(1,2,3,4,5,6,7,8,9,10);
2584     if (runTest[10]) func10_1();
2585     if (runTest[11]) func11_1();
2586     if (runTest[12]) func12_1();
2587     if (runTest[13]) func13_1(131,132,133,134,135);
2588     if (runTest[14]) func14_1();
2589     if (runTest[15]) func15_1();
2590     if (runTest[16]) func16_1();
2591     if (runTest[17]) func17_1();
2592     if (runTest[18]) func18_1();
2593     if (runTest[19]) func19_1();
2594     if (runTest[20]) func20_1();
2595     if (runTest[21]) func21_1();
2596     if (runTest[22]) func22_1();
2597     if (runTest[23]) func23_1();
2598     if (runTest[24]) func24_1();
2599     if (runTest[25]) func25_1();
2600     if (runTest[26]) func26_1();
2601     if (runTest[27]) func27_1();
2602     if (runTest[28]) func28_1();
2603     if (runTest[29]) func29_1();
2604     if (runTest[30]) func30_1();
2605
2606     if( runTest[ 31 ] ) func31_1();
2607     if( runTest[ 32 ] ) func32_1();
2608
2609 #ifdef __cplusplus
2610    
2611     if (runTest[33]) {
2612        arg_test test33;
2613        test33.func_cpp();
2614     }
2615
2616     if (runTest[34]) {
2617        overload_func_test test34;
2618        test34.func_cpp();
2619     }
2620
2621     if (runTest[35]) {
2622          overload_op_test test35;
2623          test35.func_cpp();
2624     }
2625
2626     if (runTest[36]) {
2627          static_test test36;
2628          test36.func_cpp();
2629     }
2630
2631     if (runTest[37]) {
2632          namespace_test test37;
2633          test37.func_cpp();
2634     }
2635
2636     if (runTest[38]) {
2637          exception_test test38;
2638          test38.func_cpp();
2639     }
2640
2641     if (runTest[39]) {
2642          template_test test39;
2643          test39.func_cpp();
2644     }
2645
2646     if (runTest[40]) {
2647          decl_test test40;
2648          test40.func_cpp();
2649     }
2650
2651     if (runTest[41]) {
2652          derivation_test test41;
2653          test41.func_cpp();
2654     }
2655     if (runTest[42]) {
2656          stdlib_test1 test42;
2657          test42.func_cpp();
2658     }
2659     if (runTest[43]) {
2660          stdlib_test2 test43;
2661          test43.func_cpp();
2662     }
2663     if (runTest[44]) {
2664          func_test test44;
2665          test44.func_cpp();
2666     }
2667 #endif
2668
2669     /* See how we did running the tests. */
2670     for (i=1; i <= MAX_TEST; i++) {
2671         if (runTest[i] && !passedTest[i]) testsFailed++;
2672     }
2673
2674     if (!testsFailed) {
2675         if (runAllTests) {
2676             printf("All tests passed\n");
2677         } else {
2678             printf("All requested tests passed\n");
2679         }
2680     } else {
2681         printf("**Failed** %d test%c\n",testsFailed,(testsFailed>1)?'s':' ');
2682     }
2683
2684     dprintf("Mutatee %s terminating.\n", argv[0]);
2685     return (testsFailed ? 127 : 0);
2686 }