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