Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / tests / src / test1.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 // $Id: test1.C,v 1.52 2000/03/22 19:08:48 tikir Exp 
33 //
34 // libdyninst validation suite test #1
35 //    Author: Jeff Hollingsworth (1/7/97)
36 //        derived from a previous test by Bryan Buck
37 //
38
39 //  This program tests the basic features of the dyninst API.  
40 //      The mutatee that goes with this file is test1.mutatee.c
41 //      
42 //  Naming conventions:
43 //      All functions, variables, etc are name funcXX_YY, exprXX_YY, etc.
44 //          XX is the test number
45 //          YY is the instance withing the test
46 //          func1_2 is the second function used in test case #1.
47 //
48
49 #include <stdio.h>
50 #include <string.h>
51 #include <ctype.h>
52 #include <assert.h>
53 #include <stdarg.h>
54 #ifdef i386_unknown_nt4_0
55 #define WIN32_LEAN_AND_MEAN
56 #include <windows.h>
57 #include <winsock2.h>
58 #include <winbase.h>
59 #else
60 #include <unistd.h>
61 #endif
62
63 #include <iostream>
64 using namespace std;
65
66 #include "BPatch.h"
67 #include "BPatch_Vector.h"
68 #include "BPatch_thread.h"
69 #include "BPatch_snippet.h"
70 #include "BPatch_statement.h"
71 #include "test_util.h"
72 #include "test1.h"
73 #include "BPatch_Set.h"
74 #include "BPatch_flowGraph.h"
75 #include "BPatch_function.h"
76 #include "BPatch_point.h"
77
78 // #include <vector.h>
79
80 int debugPrint = 0; // internal "mutator" tracing
81 int errorPrint = 1; // external "dyninst" tracing (via errorFunc)
82
83 bool forceRelocation = false; // force relocation of functions
84 bool delayedParse = false;
85
86 int mutateeCplusplus = 0;
87 int mutateeFortran = 0;
88 int mutateeXLC = 0;
89 int mutateeF77 = 0;
90 bool runAllTests = true;
91 const unsigned int MAX_TEST = 40;
92 bool runTest[MAX_TEST+1];
93 bool passedTest[MAX_TEST+1];
94 int saveWorld = 0;
95 // Default to on
96 int mergeTramp = 1;
97
98
99
100 template class BPatch_Vector<BPatch_variableExpr*>;
101 template class BPatch_Set<int>;
102
103 BPatch *bpatch;
104
105 static const char *mutateeNameRoot = "test1.mutatee";
106 static const char *libNameAroot = "libtestA";
107 static const char *libNameBroot = "libtestB";
108 char libNameA[64], libNameB[64];
109
110 // control debug printf statements
111 void dprintf(const char *fmt, ...) {
112    va_list args;
113    va_start(args, fmt);
114
115    if(debugPrint)
116       vfprintf(stderr, fmt, args);
117
118    va_end(args);
119
120    fflush(stderr);
121 }
122
123 /**************************************************************************
124  * Error callback
125  **************************************************************************/
126
127 #define DYNINST_NO_ERROR -1
128
129 int expectError = DYNINST_NO_ERROR;
130
131 void errorFunc(BPatchErrorLevel level, int num, const char * const *params)
132 {
133     if (num == 0) {
134         // conditional reporting of warnings and informational messages
135         if (errorPrint) {
136             if ((level == BPatchInfo) || (level == BPatchWarning))
137               { if (errorPrint > 1) printf("%s\n", params[0]); }
138             else {
139                 printf("%s", params[0]);
140             }
141         }
142     } else {
143         // reporting of actual errors
144         char line[256];
145         const char *msg = bpatch->getEnglishErrorString(num);
146         bpatch->formatErrorString(line, sizeof(line), msg, params);
147         
148         if (num != expectError) {
149           if(num != 112)
150             printf("Error #%d (level %d): %s\n", num, level, line);
151         
152             // We consider some errors fatal.
153             if (num == 101) {
154                exit(-1);
155             }
156         }
157     }
158 }
159
160 void createInstPointError(BPatchErrorLevel level, int num, const char * const *params)
161 {
162     if (num != 117 && num != 118)
163         errorFunc(level, num, params);
164 }
165
166 /**************************************************************************
167  * Utility functions
168  **************************************************************************/
169
170 // check that the cost of a snippet is sane.  Due to differences between
171 //   platforms, it is impossible to check this exactly in a machine independent
172 //   manner.
173 void checkCost(BPatch_snippet snippet)
174 {
175     float cost;
176     BPatch_snippet copy;
177
178     // test copy constructor too.
179     copy = snippet;
180
181     cost = snippet.getCost();
182     dprintf("Snippet cost=%g\n", cost);
183     if (cost < 0.0) {
184         printf("*Error*: negative snippet cost\n");
185     }
186     else if (cost > 0.01) {
187         printf("*Error*: snippet cost of %f, exceeds max expected of 0.1",
188             cost);
189     }
190 }
191
192 int functionNameMatch(const char *gotName, const char *targetName) 
193 {
194     if (!strcmp(gotName, targetName)) return 0;
195
196     if (!strncmp(gotName, targetName, strlen(targetName)) &&
197         (strlen(targetName) == strlen(gotName)-1) &&
198         (gotName[strlen(targetName)] == '_'))
199         return 0;
200
201     return 1;
202 }
203
204
205 //
206 // Replace all calls in "inFunction" to "callTo" with calls to "replacement."
207 // If "replacement" is NULL, them use removeFunctionCall instead of
208 // replaceFunctionCall.
209 // Returns the number of replacements that were performed.
210 //
211 int replaceFunctionCalls(BPatch_thread *appThread, BPatch_image *appImage,
212                          const char *inFunction, const char *callTo, 
213                          const char *replacement, int testNo, 
214                          const char *testName, int callsExpected = -1)
215 {
216     int numReplaced = 0;
217
218     BPatch_Vector<BPatch_function *> found_funcs;
219     if ((NULL == appImage->findFunction(inFunction, found_funcs)) || !found_funcs.size()) {
220       fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
221       fprintf(stderr, "    Unable to find function %s\n",
222               inFunction);
223       exit(1);
224     }
225
226     if (1 < found_funcs.size()) {
227       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
228               __FILE__, __LINE__, found_funcs.size(), inFunction);
229     }
230
231     BPatch_Vector<BPatch_point *> *points = found_funcs[0]->findPoint(BPatch_subroutine);
232
233     if (!points || (!points->size() )) {
234         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
235         fprintf(stderr, "    %s[%d]: Unable to find point in %s - subroutine calls: pts = %p\n",
236                 __FILE__, __LINE__, inFunction,points);
237         exit(1);
238     }
239
240     BPatch_function *call_replacement = NULL;
241     if (replacement != NULL) {
242       
243       BPatch_Vector<BPatch_function *> bpfv;
244       if (NULL == appImage->findFunction(replacement, bpfv) || !bpfv.size()
245           || NULL == bpfv[0]){
246         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
247         fprintf(stderr, "    Unable to find function %s\n", replacement);
248         exit(1);
249       }
250       call_replacement = bpfv[0];
251     }
252
253     for (unsigned int n = 0; n < points->size(); n++) {
254         BPatch_function *func;
255
256         if ((func = (*points)[n]->getCalledFunction()) == NULL) continue;
257
258         char fn[256];
259         if (func->getName(fn, 256) == NULL) {
260             fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
261             fprintf(stderr, "    Can't get name of called function in %s\n",
262                     inFunction);
263             exit(1);
264         }
265         if (functionNameMatch(fn, callTo) == 0) {
266             if (replacement == NULL)
267                 appThread->removeFunctionCall(*((*points)[n]));
268             else {
269                 assert(call_replacement);
270                 appThread->replaceFunctionCall(*((*points)[n]),
271                                                *call_replacement);
272             }
273             numReplaced++;
274         }
275     }
276
277     if (callsExpected > 0 && callsExpected != numReplaced) {
278         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
279         fprintf(stderr, "    Expected to find %d %s to %s in %s, found %d\n",
280                 callsExpected, callsExpected == 1 ? "call" : "calls",
281                 callTo, inFunction, numReplaced);
282         exit(1);
283     }
284
285
286     return numReplaced;
287 }
288
289
290 //
291 // Return a pointer to a string identifying a BPatch_procedureLocation
292 //
293 const char *locationName(BPatch_procedureLocation l)
294 {
295     switch(l) {
296       case BPatch_entry:
297         return "entry";
298       case BPatch_exit:
299         return "exit";
300       case BPatch_subroutine:
301         return "call points";
302       case BPatch_longJump:
303         return "long jump";
304       case BPatch_allLocations:
305         return "all";
306       default:
307         return "<invalid BPatch_procedureLocation>";
308     };
309 }
310
311
312 //
313 // Insert "snippet" at the location "loc" in the function "inFunction."
314 // Returns the value returned by BPatch_thread::insertSnippet.
315 //
316 BPatchSnippetHandle *insertSnippetAt(BPatch_thread *appThread,
317                                BPatch_image *appImage, const char *inFunction, 
318                                BPatch_procedureLocation loc, 
319                                BPatch_snippet &snippet,
320                                int testNo, const char *testName)
321 {
322     // Find the point(s) we'll be instrumenting
323
324     BPatch_Vector<BPatch_function *> found_funcs;
325     if ((NULL == appImage->findFunction(inFunction, found_funcs)) || !found_funcs.size()) {
326       fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
327       fprintf(stderr, "    Unable to find function %s\n",
328               inFunction);
329       exit(1);
330     }
331
332     if (1 < found_funcs.size()) {
333       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
334               __FILE__, __LINE__, found_funcs.size(), inFunction);
335     }
336
337     BPatch_Vector<BPatch_point *> *points = found_funcs[0]->findPoint(loc);
338
339     if (!points) {
340         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
341         fprintf(stderr, "    Unable to find point %s - %s\n",
342                 inFunction, locationName(loc));
343         exit(-1);
344     }
345
346     checkCost(snippet);
347     return appThread->insertSnippet(snippet, *points);
348 }
349
350 //
351 // Create a snippet that calls the function "funcName" with no arguments
352 //
353 BPatch_snippet *makeCallSnippet(BPatch_image *appImage, const char *funcName,
354                                 int testNo, const char *testName)
355 {
356   BPatch_Vector<BPatch_function *> bpfv;
357   if (NULL == appImage->findFunction(funcName, bpfv) || !bpfv.size()
358       || NULL == bpfv[0]){
359     fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
360     fprintf(stderr, "    Unable to find function %s\n", funcName);
361     exit(1);
362   }
363   BPatch_function *call_func = bpfv[0];
364  
365     BPatch_Vector<BPatch_snippet *> nullArgs;
366     BPatch_snippet *ret = new BPatch_funcCallExpr(*call_func, nullArgs);
367
368     if (ret == NULL) {
369         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
370         fprintf(stderr, "    Unable to create snippet to call %s\n", funcName);
371         exit(1);
372     }
373
374     return ret;
375 }
376
377 //
378 // Insert a snippet to call function "funcName" with no arguments into the
379 // procedure "inFunction" at the points given by "loc."
380 //
381 BPatchSnippetHandle *insertCallSnippetAt(BPatch_thread *appThread,
382                             BPatch_image *appImage, const char *inFunction,
383                             BPatch_procedureLocation loc, const char *funcName,
384                             int testNo, const char *testName)
385 {
386     BPatch_snippet *call_expr =
387        makeCallSnippet(appImage, funcName, testNo, testName);
388
389     BPatchSnippetHandle *ret = insertSnippetAt(appThread, appImage,
390                                                inFunction, loc, *call_expr,
391                                                testNo, testName);
392     if (ret == NULL) {
393         fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
394         fprintf(stderr, "    Unable to insert snippet to call function %s\n",
395                 funcName);
396         exit(-1);
397     }
398
399     delete call_expr;
400
401     return ret;
402 }
403
404 // Wrapper function to find variables
405 // For Fortran, will look for lowercase variable, if mixed case not found
406 BPatch_variableExpr *findVariable(BPatch_image *appImage, const char* var,
407                                   BPatch_Vector <BPatch_point *> *point = NULL)
408 {
409   //BPatch_variableExpr *FortVar = NULL;
410     BPatch_variableExpr *ret = NULL;
411     int i, numchars = strlen (var);
412     char *lowercase = new char [numchars];
413     int temp = expectError;
414
415     if (mutateeFortran && point) {
416             strcpy (lowercase, var);
417             expectError = 100;
418             for (i = 0; i < numchars; i++)
419                 lowercase [i] = tolower (lowercase [i]);
420             ret = appImage->findVariable (*(*point) [0], lowercase);
421         if (!ret) {
422             expectError = temp;
423             ret = appImage->findVariable (*(*point) [0], var);
424         }
425     } else {
426         ret = appImage->findVariable (var);
427     }
428
429     expectError = temp;
430     delete [] lowercase;
431     return ret;
432 }
433
434 /**************************************************************************
435  * Tests
436  **************************************************************************/
437
438 //
439 // Start Test Case #1 - (zero arg function call)
440 //
441 void mutatorTest1(BPatch_thread *appThread, BPatch_image *appImage)
442 {
443   const char* testName = "zero arg function call";
444   int testNo = 1;
445
446     // Find the entry point to the procedure "func1_1"
447
448   BPatch_Vector<BPatch_function *> found_funcs;
449   if ((NULL == appImage->findFunction("func1_1", found_funcs)) || !found_funcs.size()) {
450     fprintf(stderr, "    Unable to find function %s\n",
451             "func1_1");
452     //  find the base exec module and dump all the functions:
453     BPatch_module *m;
454    if (mutateeFortran) m = appImage->findModule("test1.mutateeFort.F");
455    else  m = appImage->findModule("test1.mutatee.c");
456     if (!m) {
457       fprintf(stderr, "%s[%d]:  cannot find base module: test1.mutatee.c. Modules:\n", 
458             __FILE__, __LINE__);
459       BPatch_Vector<BPatch_module *> *mods = appImage->getModules();
460       for (unsigned int i = 0; i < mods->size(); ++i) {
461          BPatch_module *mod = (*mods)[i];
462          char modnm[1024];
463          mod->getName(modnm, 1024);
464          fprintf(stderr, "\t%s\n", modnm);
465       }
466       exit(1);
467     }
468     BPatch_Vector<BPatch_function *> *funcs = m->getProcedures();
469     if (!funcs) {
470       fprintf(stderr, "%s[%d]:  cannot get procedures\n", __FILE__, __LINE__);
471       exit(1);
472     }
473     fprintf(stderr, "%s[%d]:  have these functions:\n", __FILE__, __LINE__);
474     for (unsigned int i = 0; i < funcs->size(); ++i) {
475       BPatch_function *f = (*funcs)[i];
476       char buf1[1024];
477       char buf2[1024];
478       f->getName(buf1, 1024);
479       f->getMangledName(buf2, 1024);
480       fprintf(stderr, "\t%s--%s\n", buf1, buf2);
481     }
482     exit(1);
483   }
484   
485   if (1 < found_funcs.size()) {
486     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
487             __FILE__, __LINE__, found_funcs.size(), "func1_1");
488   }
489   
490   BPatch_Vector<BPatch_point *> *point1_1 = found_funcs[0]->findPoint(BPatch_entry);
491
492
493   if (!point1_1 || ((*point1_1).size() == 0)) {
494     fprintf(stderr, "**Failed** test #%d (%s)\n", testNo,testName);
495     fprintf(stderr, "    Unable to find entry point to \"func1_1.\"\n");
496     exit(1);
497   }
498
499   BPatch_Vector<BPatch_function *> bpfv;
500   char *fn = "call1_1";
501   if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
502       || NULL == bpfv[0]){
503     fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
504     fprintf(stderr, "    Unable to find function %s\n", fn);
505     exit(1);
506   }
507   BPatch_function *call1_func = bpfv[0];
508   
509   BPatch_Vector<BPatch_snippet *> call1_args;
510   BPatch_funcCallExpr call1Expr(*call1_func, call1_args);
511
512   BPatch_Vector<BPatch_snippet *> constVec;
513   BPatch_Vector<BPatch_snippet *> arithVec;
514
515   for (unsigned i = 0; i < 101; i++) {
516       constVec.push_back(new BPatch_constExpr(i));
517       constVec.push_back(new BPatch_constExpr(i+100));
518   }
519   for (unsigned i = 0; i < 100; i++) {
520       arithVec.push_back(new BPatch_arithExpr(BPatch_plus,
521                                               *(constVec[i]),
522                                               *(constVec[i+100])));
523   }
524   // Duplicate 100 operations...
525   for (unsigned i = 0; i < 100; i++) {
526       arithVec.push_back(arithVec[i]);
527   }
528   // And again.
529   for (unsigned i = 0; i < 100; i++) {
530       arithVec.push_back(arithVec[i]);
531   }
532
533   BPatch_sequence expr(arithVec);
534
535
536   dprintf("Inserted snippet2\n");
537   checkCost(call1Expr);
538   appThread->insertSnippet(call1Expr, *point1_1);
539   //appThread->insertSnippet(expr, *point1_1);
540 }
541
542 //
543 // Start Test Case #2 - mutator side (call a four argument function)
544 //
545 void mutatorTest2(BPatch_thread *appThread, BPatch_image *appImage)
546 {
547   const char* testName = "four parameter function";
548   int testNo = 2;
549     // Find the entry point to the procedure "func2_1"
550
551   BPatch_Vector<BPatch_function *> found_funcs;
552   if ((NULL == appImage->findFunction("func2_1", found_funcs)) || !found_funcs.size()) {
553     fprintf(stderr, "    Unable to find function %s\n",
554             "func2_1");
555     exit(1);
556   }
557   
558   if (1 < found_funcs.size()) {
559     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
560             __FILE__, __LINE__, found_funcs.size(), "func2_1");
561   }
562   
563   BPatch_Vector<BPatch_point *> *point2_1 = found_funcs[0]->findPoint(BPatch_entry);
564
565   if (!point2_1 || ((*point2_1).size() == 0)) {
566     fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
567     fprintf(stderr, "    Unable to find entry point to \"func2_1.\"\n");
568     exit(1);
569   }
570
571   BPatch_Vector<BPatch_function *> bpfv;
572   char *fn = "call2_1";
573   if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
574       || NULL == bpfv[0]){
575     fprintf(stderr, "**Failed** test #%d (%s)\n", testNo, testName);
576     fprintf(stderr, "    Unable to find function %s\n", fn);
577     exit(1);
578   }
579   BPatch_function *call2_func = bpfv[0];
580
581     void *ptr;
582
583 #if defined(mips_sgi_irix6_4)        \
584  || defined(x86_64_unknown_linux2_4) \
585  || defined(rs6000_ibm_aix64)        \
586  || defined(ppc64_linux)
587
588     BPatch_variableExpr *pointerSizeVar = appImage->findVariable("pointerSize");
589     if (!pointerSizeVar) {
590         fprintf(stderr, "**Failed** test #2 (four parameter function)\n");
591         fprintf(stderr, "    Unable to locate variable pointerSize\n");
592         exit(1);
593     }
594
595     int pointerSize;
596     if (!pointerSizeVar->readValue(&pointerSize)) {
597         fprintf(stderr, "**Failed** test #2 (four parameter function)\n");
598         fprintf(stderr, "    Unable to read value of variable pointerSize\n");
599         exit(1);
600     }
601
602     assert(sizeof(void *) == sizeof(unsigned long) &&
603            sizeof(void *) == TEST_PTR_SIZE);
604
605     /* Determine the size of pointer we should use dynamically. */
606     if (pointerSize == 4) {
607         ptr = TEST_PTR_32BIT;
608     } else if (pointerSize == 8) {
609         ptr = TEST_PTR_64BIT;
610     } else {
611         fprintf(stderr, "**Failed** test #2 (four parameter function)\n");
612         fprintf(stderr, "    Unexpected value for pointerSize\n");
613         exit(1);
614     }
615 #else
616     /* For platforms where there is only one possible size for a pointer. */
617     ptr = TEST_PTR;
618 #endif
619
620     BPatch_Vector<BPatch_snippet *> call2_args;
621
622     BPatch_constExpr expr2_1 (0), expr2_2 (0), expr2_3 (0), expr2_4 (0);
623
624     if (mutateeFortran) {
625         BPatch_variableExpr *expr2_5 = appThread->malloc (*appImage->findType ("int"));
626         BPatch_variableExpr *expr2_6 = appThread->malloc (*appImage->findType ("int"));
627
628         expr2_1 = expr2_5->getBaseAddr ();
629         expr2_2 = expr2_6->getBaseAddr ();
630
631         BPatch_arithExpr expr2_7 (BPatch_assign, *expr2_5, BPatch_constExpr(1));
632         appThread->insertSnippet (expr2_7, *point2_1);
633
634         BPatch_arithExpr expr2_8 (BPatch_assign, *expr2_6, BPatch_constExpr(2));
635         appThread->insertSnippet (expr2_8, *point2_1);
636
637         expr2_3 = "testString2_1";
638         expr2_4 = 13;
639     } else {
640         expr2_1 = 1;
641         expr2_2 = 2;
642         expr2_3 = "testString2_1";
643         expr2_4 = ptr;
644     }
645
646     call2_args.push_back(&expr2_1);
647     call2_args.push_back(&expr2_2);
648     call2_args.push_back(&expr2_3);
649     call2_args.push_back(&expr2_4);
650
651     BPatch_funcCallExpr call2Expr(*call2_func, call2_args);
652
653     dprintf("Inserted snippet2\n");
654     checkCost(call2Expr);
655     appThread->insertSnippet(call2Expr, *point2_1, BPatch_callBefore, BPatch_lastSnippet);
656 }
657
658 //
659 // Start Test Case #3 - mutator side (passing variables to function)
660 //
661 void mutatorTest3(BPatch_thread *appThread, BPatch_image *appImage)
662 {
663   // Find the entry point to the procedure "func3_1"
664
665   BPatch_Vector<BPatch_function *> found_funcs;
666   if ((NULL == appImage->findFunction("func3_1", found_funcs)) || !found_funcs.size()) {
667     fprintf(stderr, "    Unable to find function %s\n",
668             "func3_1");
669     exit(1);
670   }
671   
672   if (1 < found_funcs.size()) {
673     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
674             __FILE__, __LINE__, found_funcs.size(), "func3_1");
675   }
676   
677   BPatch_Vector<BPatch_point *> *point3_1 = found_funcs[0]->findPoint(BPatch_entry);
678
679     if (!point3_1 || ((*point3_1).size() == 0)) {
680         fprintf(stderr, "Unable to find entry point to \"func3_1.\"\n");
681         exit(1);
682     }
683
684   BPatch_Vector<BPatch_function *> bpfv;
685   char *fn = "call3_1";
686   if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
687       || NULL == bpfv[0]){
688     fprintf(stderr, "    Unable to find function %s\n", fn);
689     exit(1);
690   }
691   BPatch_function *call3_func = bpfv[0];
692
693     BPatch_Vector<BPatch_snippet *> call3_args;
694
695   BPatch_Vector<BPatch_function *> found_funcs2;
696   if ((NULL == appImage->findFunction("call3_1", found_funcs2)) || !found_funcs2.size()) {
697     fprintf(stderr, "    Unable to find function %s\n",
698             "call3_1");
699     exit(1);
700   }
701   
702   if (1 < found_funcs.size()) {
703     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
704             __FILE__, __LINE__, found_funcs2.size(), "call3_1");
705   }
706   
707   BPatch_Vector<BPatch_point *> *call3_1 = found_funcs2[0]->findPoint(BPatch_subroutine);
708
709     if (!call3_1 || ((*call3_1).size() == 0)) {
710         fprintf(stderr, "    Unable to find entry point to \"call3_1.\"\n");
711         exit(1);
712     }
713
714     BPatch_variableExpr *expr3_1 = findVariable (appImage, "globalVariable3_1", call3_1);
715
716     if (!expr3_1) {
717         fprintf(stderr, "**Failed** test #3 (passing variables)\n");
718         fprintf(stderr, "    Unable to locate variable globalVariable3_1\n");
719         exit(1);
720     }
721
722     // see if we can find the address
723     if (expr3_1->getBaseAddr() <= 0) {
724         printf("*Error*: address %p for globalVariable3_1 is not valid\n",
725             expr3_1->getBaseAddr());
726     }
727
728     BPatch_variableExpr *expr3_2 = appThread->malloc(*appImage->findType("int"));
729     if (!expr3_2) {
730         fprintf(stderr, "**Failed** test #3 (passing variables)\n");
731         fprintf(stderr, "    Unable to create new int variable\n");
732         exit(1);
733     }
734
735         if (mutateeFortran) {
736                 BPatch_constExpr expr3_3 (expr3_1->getBaseAddr ());
737                 BPatch_constExpr expr3_4 (expr3_2->getBaseAddr ());
738
739             call3_args.push_back (&expr3_3);
740             call3_args.push_back (&expr3_4);
741         } else {
742             call3_args.push_back(expr3_1);
743             call3_args.push_back(expr3_2);
744         }
745
746     BPatch_funcCallExpr call3Expr(*call3_func, call3_args);
747     checkCost(call3Expr);
748     appThread->insertSnippet(call3Expr, *point3_1);
749
750     BPatch_arithExpr expr3_5(BPatch_assign, *expr3_2, BPatch_constExpr((int)32));
751     checkCost(expr3_5);
752     appThread->insertSnippet(expr3_5, *point3_1);
753
754     dprintf("Inserted snippet3\n");
755 }
756
757 //
758 // Start Test Case #4 - mutator side (sequence)
759 //      Use the BPatch sequence operation to glue to expressions togehter.
760 //      The test is constructed to verify the correct execution order.
761 //
762 void mutatorTest4(BPatch_thread *appThread, BPatch_image *appImage)
763 {
764     // Find the entry point to the procedure "func4_1"
765   BPatch_Vector<BPatch_function *> found_funcs;
766   if ((NULL == appImage->findFunction("func4_1", found_funcs)) || !found_funcs.size()) {
767      fprintf(stderr, "    Unable to find function %s\n",
768             "func4_1");
769     exit(1);
770   }
771   
772   if (1 < found_funcs.size()) {
773     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
774             __FILE__, __LINE__, found_funcs.size(), "func4_1");
775   }
776   
777   BPatch_Vector<BPatch_point *> *point4_1 = found_funcs[0]->findPoint(BPatch_entry);
778
779     if (!point4_1 || ((*point4_1).size() == 0)) {
780         fprintf(stderr, "Unable to find entry point to \"func4_1\".\n");
781         exit(1);
782     }
783
784     BPatch_variableExpr *expr4_1 = findVariable (appImage, "globalVariable4_1", point4_1);
785
786     if (!expr4_1) {
787         fprintf(stderr, "**Failed** test #4 (sequence)\n");
788         fprintf(stderr, "    Unable to locate variable globalVariable4_1\n");
789         exit(1);
790     }
791
792     BPatch_arithExpr expr4_2(BPatch_assign, *expr4_1, BPatch_constExpr(42));
793     BPatch_arithExpr expr4_3(BPatch_assign, *expr4_1, BPatch_constExpr(43));
794
795     BPatch_Vector<BPatch_snippet*> vect4_1;
796     vect4_1.push_back(&expr4_2);
797     vect4_1.push_back(&expr4_3);
798
799     BPatch_sequence expr4_4(vect4_1);
800     checkCost(expr4_4);
801     appThread->insertSnippet(expr4_4, *point4_1);
802 }
803
804 //
805 // Start Test Case #5 - mutator side (if w.o. else)
806 //
807 void mutatorTest5(BPatch_thread *appThread, BPatch_image *appImage)
808 {
809
810     // Find the entry point to the procedure "func5_2"
811     
812   BPatch_Vector<BPatch_function *> found_funcs;
813   if ((NULL == appImage->findFunction("func5_2", found_funcs)) || !found_funcs.size()) {
814      fprintf(stderr, "    Unable to find function %s\n",
815             "func5_2");
816     exit(1);
817   }
818   
819   if (1 < found_funcs.size()) {
820     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
821             __FILE__, __LINE__, found_funcs.size(), "func5_2");
822   }
823   
824   BPatch_Vector<BPatch_point *> *point5_1 = found_funcs[0]->findPoint(BPatch_entry);  
825
826     if (!point5_1 || ((*point5_1).size() == 0)) {
827         fprintf(stderr, "Unable to find entry point to \"func5_2\".\n");
828         exit(1);
829     }
830
831  BPatch_Vector<BPatch_function *> found_funcs2;
832   if ((NULL == appImage->findFunction("func5_1", found_funcs2)) || !found_funcs2.size()) {
833      fprintf(stderr, "    Unable to find function %s\n",
834             "func5_1");
835     exit(1);
836   }
837   
838   if (1 < found_funcs2.size()) {
839     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
840             __FILE__, __LINE__, found_funcs2.size(), "func5_1");
841   }
842   
843   BPatch_Vector<BPatch_point *> *point5_2 = found_funcs2[0]->findPoint(BPatch_subroutine);  
844     
845   if (!point5_2 || ((*point5_2).size() == 0)) {
846         fprintf(stderr, "Unable to find entry point to \"func5_1\".\n");
847         exit(1);
848     }
849
850     BPatch_variableExpr *expr5_1 = findVariable (appImage, "globalVariable5_1", point5_2);
851     BPatch_variableExpr *expr5_2 = findVariable (appImage, "globalVariable5_2", point5_2);
852
853     if (!expr5_1 || !expr5_2) {
854         fprintf(stderr, "**Failed** test #5 (1f w.o. else)\n");
855         fprintf(stderr, "    Unable to locate variable globalVariable5_1 or ");
856         fprintf(stderr, "    variable globalVariable5_2\n");
857         exit(1);
858     }
859
860     BPatch_Vector<BPatch_snippet*> vect5_1;
861
862     // if (0 == 1) globalVariable5_1 = 52;
863     BPatch_ifExpr expr5_3(
864         BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0), BPatch_constExpr(1)), 
865         BPatch_arithExpr(BPatch_assign, *expr5_1, BPatch_constExpr(52)));
866
867     // if (1 == 1) globalVariable5_2 = 53;
868     BPatch_ifExpr expr5_4(
869         BPatch_boolExpr(BPatch_eq, BPatch_constExpr(1), BPatch_constExpr(1)), 
870         BPatch_arithExpr(BPatch_assign, *expr5_2, BPatch_constExpr(53)));
871
872     vect5_1.push_back(&expr5_3);
873     vect5_1.push_back(&expr5_4);
874     
875     BPatch_sequence expr5_5(vect5_1);
876     checkCost(expr5_5);
877     appThread->insertSnippet(expr5_5, *point5_1);
878 }
879
880 //
881 // Start Test Case #6 - mutator side (arithmetic operators)
882 //
883 void mutatorTest6(BPatch_thread *appThread, BPatch_image *appImage)
884 {
885     // Find the entry point to the procedure "func6_2"
886
887     
888   BPatch_Vector<BPatch_function *> found_funcs;
889   if ((NULL == appImage->findFunction("func6_2", found_funcs)) || !found_funcs.size()) {
890     fprintf(stderr, "    Unable to find function %s\n",
891             "func6_2");
892     exit(1);
893   }
894   
895   if (1 < found_funcs.size()) {
896     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
897             __FILE__, __LINE__, found_funcs.size(), "func6_2");
898   }
899   
900   BPatch_Vector<BPatch_point *> *point6_1 = found_funcs[0]->findPoint(BPatch_entry);  
901
902   if (!point6_1 || ((*point6_1).size() == 0)) {
903     fprintf(stderr, "Unable to find entry point to \"func6_2\".\n");
904     exit(1);
905   }
906
907   BPatch_Vector<BPatch_function *> found_funcs2;
908   if ((NULL == appImage->findFunction("func6_1", found_funcs2)) || !found_funcs2.size()) {
909      fprintf(stderr, "    Unable to find function %s\n",
910             "func6_1");
911     exit(1);
912   }
913   
914   if (1 < found_funcs2.size()) {
915     fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
916             __FILE__, __LINE__, found_funcs2.size(), "func6_1");
917   }
918   
919   BPatch_Vector<BPatch_point *> *point6_2 = found_funcs2[0]->findPoint(BPatch_subroutine);  
920
921     if (!point6_2 || ((*point6_2).size() == 0)) {
922         fprintf(stderr, "Unable to find entry point to \"func6_1\".\n");
923         exit(1);
924     }
925
926     BPatch_variableExpr *expr6_1, *expr6_2, *expr6_3, *expr6_4, *expr6_5, *expr6_6,
927         *expr6_1a, *expr6_2a, *expr6_3a, *expr6_4a, *expr6_5a, *expr6_6a,
928         *constVar1, *constVar2, *constVar3, *constVar5, *constVar6,
929         *constVar10, *constVar60, *constVar64, *constVar66, *constVar67;
930
931     expr6_1 = findVariable(appImage, "globalVariable6_1", point6_2);
932     expr6_2 = findVariable(appImage, "globalVariable6_2", point6_2);
933     expr6_3 = findVariable(appImage, "globalVariable6_3", point6_2);
934     expr6_4 = findVariable(appImage, "globalVariable6_4", point6_2);
935     expr6_5 = findVariable(appImage, "globalVariable6_5", point6_2);
936     expr6_6 = findVariable(appImage, "globalVariable6_6", point6_2);
937     expr6_1a = findVariable(appImage, "globalVariable6_1a", point6_2);
938     expr6_2a = findVariable(appImage, "globalVariable6_2a", point6_2);
939     expr6_3a = findVariable(appImage, "globalVariable6_3a", point6_2);
940     expr6_4a = findVariable(appImage, "globalVariable6_4a", point6_2);
941     expr6_5a = findVariable(appImage, "globalVariable6_5a", point6_2);
942     expr6_6a = findVariable(appImage, "globalVariable6_6a", point6_2);
943
944     constVar1 = findVariable(appImage, "constVar1", point6_2);
945     constVar2 = findVariable(appImage, "constVar2", point6_2);
946     constVar3 = findVariable(appImage, "constVar3", point6_2);
947     constVar5 = findVariable(appImage, "constVar5", point6_2);
948     constVar6 = findVariable(appImage, "constVar6", point6_2);
949     constVar10 = findVariable(appImage, "constVar10", point6_2);
950     constVar60 = findVariable(appImage, "constVar60", point6_2);
951     constVar64 = findVariable(appImage, "constVar64", point6_2);
952     constVar66 = findVariable(appImage, "constVar66", point6_2);
953     constVar67 = findVariable(appImage, "constVar67", point6_2);
954
955     if (!expr6_1 || !expr6_2 || !expr6_3 || !expr6_4 ||
956         !expr6_5 || !expr6_6 || !expr6_1a || !expr6_2a || !expr6_3a ||
957         !expr6_4a || !expr6_5a || !expr6_6a) {
958         fprintf(stderr, "**Failed** test #6 (arithmetic operators)\n");
959         fprintf(stderr, "    Unable to locate one of globalVariable6_?\n");
960         exit(1);
961     }
962
963     if (!constVar1 || !constVar2 || !constVar3 || !constVar5 ||
964         !constVar6 || !constVar10 || !constVar60 || !constVar64 || 
965         !constVar66 || !constVar67) {
966         fprintf(stderr, "**Failed** test #6 (arithmetic operators)\n");
967         fprintf(stderr, "    Unable to locate one of constVar?\n");
968         exit(1);
969     }
970
971     BPatch_Vector<BPatch_snippet*> vect6_1;
972
973     // globalVariable6_1 = 60 + 2
974     BPatch_arithExpr arith6_1 (BPatch_assign, *expr6_1,
975       BPatch_arithExpr(BPatch_plus,BPatch_constExpr(60), BPatch_constExpr(2)));
976     vect6_1.push_back(&arith6_1);
977
978     // globalVariable6_2 = 64 - 1
979     BPatch_arithExpr arith6_2 (BPatch_assign, *expr6_2, 
980       BPatch_arithExpr(BPatch_minus,BPatch_constExpr(64),BPatch_constExpr(1)));
981     vect6_1.push_back(&arith6_2);
982
983     // globalVariable6_3 = 553648128 / 25165824 = 22
984     //    - make these big constants to test loading constants larger than
985     //      small immediate - jkh 6/22/98
986     BPatch_arithExpr arith6_3 (BPatch_assign, *expr6_3, BPatch_arithExpr(
987       BPatch_divide,BPatch_constExpr(553648128),BPatch_constExpr(25165824)));
988     vect6_1.push_back(&arith6_3);
989
990     // globalVariable6_4 = 67 / 3
991     BPatch_arithExpr arith6_4 (BPatch_assign, *expr6_4, BPatch_arithExpr(
992       BPatch_divide,BPatch_constExpr(67),BPatch_constExpr(3)));
993     vect6_1.push_back(&arith6_4);
994     // globalVariable6_5 = 6 * 5
995     BPatch_arithExpr arith6_5 (BPatch_assign, *expr6_5, BPatch_arithExpr(
996       BPatch_times,BPatch_constExpr(6),BPatch_constExpr(5)));
997     vect6_1.push_back(&arith6_5);
998
999     // globalVariable6_6 = 10,3
1000     BPatch_arithExpr arith6_6 (BPatch_assign, *expr6_6, 
1001         BPatch_arithExpr(BPatch_seq,BPatch_constExpr(10),BPatch_constExpr(3)));
1002     vect6_1.push_back(&arith6_6);
1003
1004     // globalVariable6_1a = 60 + 2
1005     BPatch_arithExpr arith6_1a (BPatch_assign, *expr6_1a, 
1006       BPatch_arithExpr(BPatch_plus, *constVar60, *constVar2));
1007     vect6_1.push_back(&arith6_1a);
1008
1009     // globalVariable6_2a = 64 - 1
1010     BPatch_arithExpr arith6_2a (BPatch_assign, *expr6_2a, 
1011       BPatch_arithExpr(BPatch_minus, *constVar64, *constVar1));
1012     vect6_1.push_back(&arith6_2a);
1013
1014     // globalVariable6_3a = 66 / 3
1015     BPatch_arithExpr arith6_3a (BPatch_assign, *expr6_3a, BPatch_arithExpr(
1016       BPatch_divide, *constVar66, *constVar3));
1017     vect6_1.push_back(&arith6_3a);
1018
1019     // globalVariable6_4a = 67 / 3
1020     BPatch_arithExpr arith6_4a (BPatch_assign, *expr6_4a, BPatch_arithExpr(
1021       BPatch_divide, *constVar67, *constVar3));
1022     vect6_1.push_back(&arith6_4a);
1023
1024     // globalVariable6_5a = 6 * 5
1025     BPatch_arithExpr arith6_5a (BPatch_assign, *expr6_5a, BPatch_arithExpr(
1026       BPatch_times, *constVar6, *constVar5));
1027     vect6_1.push_back(&arith6_5a);
1028
1029     // globalVariable6_6a = 10,3
1030     // BPatch_arithExpr arith6_6a (BPatch_assign, *expr6_6a, *constVar3);
1031     //  BPatch_arithExpr(BPatch_seq, *constVar10, BPatch_constExpr(3)));
1032     BPatch_arithExpr arith6_6a (BPatch_assign, *expr6_6a,
1033         BPatch_arithExpr(BPatch_seq, *constVar10, *constVar3));
1034     vect6_1.push_back(&arith6_6a);
1035
1036     checkCost(BPatch_sequence(vect6_1));
1037     appThread->insertSnippet( BPatch_sequence(vect6_1), *point6_1);
1038 }
1039
1040 void genRelTest(BPatch_image *appImage,BPatch_Vector<BPatch_snippet*> &vect7_1,
1041                 BPatch_relOp op, int r1, int r2, const char *var1)
1042 {
1043
1044    BPatch_Vector<BPatch_function *> found_funcs;
1045     if ((NULL == appImage->findFunction("func7_1", found_funcs)) || !found_funcs.size()) {
1046         fprintf(stderr, "    Unable to find function %s\n",
1047               "func7_1");
1048       exit(1);
1049     }
1050
1051     if (1 < found_funcs.size()) {
1052       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1053               __FILE__, __LINE__, found_funcs.size(), "func7_1");
1054     }
1055
1056     BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry);
1057
1058     if (!point7_1 || ((*point7_1).size() == 0)) {
1059         fprintf(stderr, "Unable to find entry point to \"func7_1\".\n");
1060         exit(1);
1061     }
1062
1063     BPatch_variableExpr *expr1_1 = findVariable (appImage, var1, point7_1);
1064
1065     if (!expr1_1) {
1066         fprintf(stderr, "**Failed** test #7 (relational operators)\n");
1067         fprintf(stderr, "    Unable to locate variable %s\n", var1);
1068         exit(1);
1069     }
1070     BPatch_ifExpr *tempExpr1 = new BPatch_ifExpr(
1071         BPatch_boolExpr(op, BPatch_constExpr(r1), BPatch_constExpr(r2)), 
1072         BPatch_arithExpr(BPatch_assign, *expr1_1, BPatch_constExpr(72)));
1073     vect7_1.push_back(tempExpr1);
1074 }
1075
1076 void genVRelTest(BPatch_image *appImage,
1077                  BPatch_Vector<BPatch_snippet*> &vect7_1, 
1078                  BPatch_relOp op, BPatch_variableExpr *r1, 
1079                  BPatch_variableExpr *r2, const char *var1)
1080 {
1081
1082    BPatch_Vector<BPatch_function *> found_funcs;
1083     if ((NULL == appImage->findFunction("func7_1", found_funcs)) || !found_funcs.size()) {
1084       fprintf(stderr, "    Unable to find function %s\n",
1085               "func7_1");
1086       exit(1);
1087     }
1088
1089     if (1 < found_funcs.size()) {
1090       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1091               __FILE__, __LINE__, found_funcs.size(), "func7_1");
1092     }
1093
1094     BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry);
1095
1096     if (!point7_1 || ((*point7_1).size() == 0)) {
1097         fprintf(stderr, "Unable to find entry point to \"func7_1\".\n");
1098         exit(1);
1099     }
1100
1101     BPatch_variableExpr *expr1_1 = findVariable(appImage, var1, point7_1);
1102
1103     if (!expr1_1) {
1104         fprintf(stderr, "**Failed** test #7 (relational operators)\n");
1105         fprintf(stderr, "    Unable to locate variable %s\n", var1);
1106         exit(1);
1107     }
1108     BPatch_ifExpr *tempExpr1 = new BPatch_ifExpr(
1109         BPatch_boolExpr(op, *r1, *r2), 
1110         BPatch_arithExpr(BPatch_assign, *expr1_1, BPatch_constExpr(74)));
1111     vect7_1.push_back(tempExpr1);
1112 }
1113
1114 //
1115 // Start Test Case #7 - mutator side (relational operators)
1116 //
1117 void mutatorTest7(BPatch_thread *appThread, BPatch_image *appImage)
1118 {
1119     // Find the entry point to the procedure "func7_2"
1120
1121    BPatch_Vector<BPatch_function *> found_funcs;
1122     if ((NULL == appImage->findFunction("func7_2", found_funcs)) || !found_funcs.size()) {
1123        fprintf(stderr, "    Unable to find function %s\n",
1124               "func7_2");
1125       exit(1);
1126     }
1127
1128     if (1 < found_funcs.size()) {
1129       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1130               __FILE__, __LINE__, found_funcs.size(), "func7_2");
1131     }
1132
1133     BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry);
1134
1135     if (!point7_1 || ((*point7_1).size() == 0)) {
1136         fprintf(stderr, "Unable to find entry point to \"func7_2\".\n");
1137         exit(1);
1138     }
1139
1140     BPatch_Vector<BPatch_snippet*> vect7_1;
1141
1142     genRelTest(appImage, vect7_1, BPatch_lt, 0, 1, "globalVariable7_1");
1143     genRelTest(appImage, vect7_1, BPatch_lt, 1, 0, "globalVariable7_2");
1144     genRelTest(appImage, vect7_1, BPatch_eq, 2, 2, "globalVariable7_3");
1145     genRelTest(appImage, vect7_1, BPatch_eq, 2, 3, "globalVariable7_4");
1146     genRelTest(appImage, vect7_1, BPatch_gt, 4, 3, "globalVariable7_5");
1147     genRelTest(appImage, vect7_1, BPatch_gt, 3, 4, "globalVariable7_6");
1148     genRelTest(appImage, vect7_1, BPatch_le, 3, 4, "globalVariable7_7");
1149     genRelTest(appImage, vect7_1, BPatch_le, 4, 3, "globalVariable7_8");
1150     genRelTest(appImage, vect7_1, BPatch_ne, 5, 6, "globalVariable7_9");
1151     genRelTest(appImage, vect7_1, BPatch_ne, 5, 5, "globalVariable7_10");
1152     genRelTest(appImage, vect7_1, BPatch_ge, 9, 7, "globalVariable7_11");
1153     genRelTest(appImage, vect7_1, BPatch_ge, 7, 9, "globalVariable7_12");
1154     genRelTest(appImage, vect7_1, BPatch_and, 1, 1, "globalVariable7_13");
1155     genRelTest(appImage, vect7_1, BPatch_and, 1, 0, "globalVariable7_14");
1156     genRelTest(appImage, vect7_1, BPatch_or, 1, 0, "globalVariable7_15");
1157     genRelTest(appImage, vect7_1, BPatch_or, 0, 0, "globalVariable7_16");
1158
1159    BPatch_Vector<BPatch_function *> found_funcs2;
1160     if ((NULL == appImage->findFunction("func7_1", found_funcs2)) || !found_funcs2.size()) {
1161        fprintf(stderr, "    Unable to find function %s\n",
1162               "func7_1");
1163       exit(1);
1164     }
1165
1166     if (1 < found_funcs2.size()) {
1167       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1168               __FILE__, __LINE__, found_funcs2.size(), "func7_1");
1169     }
1170
1171     BPatch_Vector<BPatch_point *> *func7_1 = found_funcs2[0]->findPoint(BPatch_subroutine);
1172
1173     if (!func7_1 || ((*func7_1).size() == 0)) {
1174         fprintf(stderr, "Unable to find entry point to \"func7_1\".\n");
1175         exit(1);
1176     }
1177
1178     BPatch_variableExpr *constVar0, *constVar1, *constVar2, *constVar3, *constVar4, *constVar5, *constVar6, *constVar7, *constVar9;
1179     constVar0 = findVariable(appImage, "constVar0", func7_1);
1180     constVar1 = findVariable(appImage, "constVar1", func7_1);
1181     constVar2 = findVariable(appImage, "constVar2", func7_1);
1182     constVar3 = findVariable(appImage, "constVar3", func7_1);
1183     constVar4 = findVariable(appImage, "constVar4", func7_1);
1184     constVar5 = findVariable(appImage, "constVar5", func7_1);
1185     constVar6 = findVariable(appImage, "constVar6", func7_1);
1186     constVar7 = findVariable(appImage, "constVar7", func7_1);
1187     constVar9 = findVariable(appImage, "constVar9", func7_1);
1188
1189     if (!constVar0 || !constVar1 || !constVar2 || !constVar3 || !constVar4 ||
1190         !constVar5 || !constVar6 || !constVar7 || !constVar9 ) {
1191         fprintf(stderr, "**Failed** test #7 (relational operators)\n");
1192         fprintf(stderr, "    Unable to locate one of constVar?\n");
1193         exit(1);
1194     }
1195
1196     genVRelTest(appImage, vect7_1, BPatch_lt, constVar0, constVar1,
1197         "globalVariable7_1a");
1198     genVRelTest(appImage, vect7_1, BPatch_lt, constVar1, constVar0, 
1199         "globalVariable7_2a");
1200     genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar2, 
1201         "globalVariable7_3a");
1202     genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar3, 
1203         "globalVariable7_4a");
1204     genVRelTest(appImage, vect7_1, BPatch_gt, constVar4, constVar3, 
1205         "globalVariable7_5a");
1206     genVRelTest(appImage, vect7_1, BPatch_gt, constVar3, constVar4, 
1207         "globalVariable7_6a");
1208     genVRelTest(appImage, vect7_1, BPatch_le, constVar3, constVar4, 
1209         "globalVariable7_7a");
1210     genVRelTest(appImage, vect7_1, BPatch_le, constVar4, constVar3, 
1211         "globalVariable7_8a");
1212     genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar6, 
1213         "globalVariable7_9a");
1214     genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar5, 
1215         "globalVariable7_10a");
1216     genVRelTest(appImage, vect7_1, BPatch_ge, constVar9, constVar7, 
1217         "globalVariable7_11a");
1218     genVRelTest(appImage, vect7_1, BPatch_ge, constVar7, constVar9, 
1219         "globalVariable7_12a");
1220     genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar1, 
1221         "globalVariable7_13a");
1222     genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar0, 
1223         "globalVariable7_14a");
1224     genVRelTest(appImage, vect7_1, BPatch_or, constVar1, constVar0, 
1225         "globalVariable7_15a");
1226     genVRelTest(appImage, vect7_1, BPatch_or, constVar0, constVar0, 
1227         "globalVariable7_16a");
1228
1229     dprintf("relops test vector length is %d\n", vect7_1.size());
1230
1231     checkCost(BPatch_sequence(vect7_1));
1232     appThread->insertSnippet( BPatch_sequence(vect7_1), *point7_1);
1233 }
1234
1235 //
1236 // Start Test Case #8 - mutator side (preserve registers - expr)
1237 //
1238 void mutatorTest8(BPatch_thread *appThread, BPatch_image *appImage)
1239 {
1240     // Find the entry point to the procedure "func8_1"
1241
1242   BPatch_Vector<BPatch_function *> found_funcs;
1243     if ((NULL == appImage->findFunction("func8_1", found_funcs)) || !found_funcs.size()) {
1244       fprintf(stderr, "    Unable to find function %s\n",
1245               "func8_1");
1246       exit(1);
1247     }
1248
1249     if (1 < found_funcs.size()) {
1250       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1251               __FILE__, __LINE__, found_funcs.size(), "func8_1");
1252     }
1253
1254     BPatch_Vector<BPatch_point *> *point8_1 = found_funcs[0]->findPoint(BPatch_entry);
1255
1256     if (!point8_1 || ((*point8_1).size() == 0)) {
1257         fprintf(stderr, "Unable to find entry point to \"func8_1\".\n");
1258         exit(1);
1259     }
1260
1261     BPatch_Vector<BPatch_snippet*> vect8_1;
1262
1263     BPatch_variableExpr *expr8_1 = findVariable(appImage, "globalVariable8_1", point8_1);
1264
1265     if (!expr8_1) {
1266         fprintf(stderr, "**Failed** test #3 (passing variables)\n");
1267         fprintf(stderr, "    Unable to locate variable globalVariable8_1\n");
1268         exit(1);
1269     }
1270
1271     BPatch_arithExpr arith8_1 (BPatch_assign, *expr8_1, 
1272       BPatch_arithExpr(BPatch_plus, 
1273             BPatch_arithExpr(BPatch_plus, 
1274                 BPatch_arithExpr(BPatch_plus, BPatch_constExpr(81), 
1275                                               BPatch_constExpr(82)),
1276                 BPatch_arithExpr(BPatch_plus, BPatch_constExpr(83), 
1277                                               BPatch_constExpr(84))),
1278             BPatch_arithExpr(BPatch_plus, 
1279                 BPatch_arithExpr(BPatch_plus, BPatch_constExpr(85), 
1280                                               BPatch_constExpr(86)),
1281                 BPatch_arithExpr(BPatch_plus, BPatch_constExpr(87), 
1282                                               BPatch_constExpr(88)))));
1283     vect8_1.push_back(&arith8_1);
1284
1285     checkCost(BPatch_sequence(vect8_1));
1286     appThread->insertSnippet( BPatch_sequence(vect8_1), *point8_1);
1287 }
1288
1289 //
1290 // Start Test Case #9 - mutator side (preserve registers - funcCall)
1291 //
1292 void mutatorTest9(BPatch_thread *appThread, BPatch_image *appImage)
1293 {
1294     // Find the entry point to the procedure "func9_1"
1295
1296   BPatch_Vector<BPatch_function *> found_funcs;
1297     if ((NULL == appImage->findFunction("func9_1", found_funcs)) || !found_funcs.size()) {
1298        fprintf(stderr, "    Unable to find function %s\n",
1299               "func9_1");
1300       exit(1);
1301     }
1302
1303     if (1 < found_funcs.size()) {
1304       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1305               __FILE__, __LINE__, found_funcs.size(), "func9_1");
1306     }
1307
1308     BPatch_Vector<BPatch_point *> *point9_1 = found_funcs[0]->findPoint(BPatch_entry);
1309
1310     if (!point9_1 || ((*point9_1).size() == 0)) {
1311         fprintf(stderr, "Unable to find entry point to \"func9_1\".\n");
1312         exit(1);
1313     }
1314
1315     BPatch_Vector<BPatch_function *> bpfv;
1316     char *fn = "call9_1";
1317     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
1318         || NULL == bpfv[0]){
1319       fprintf(stderr, "    Unable to find function %s\n", fn);
1320       exit(1);
1321     }
1322
1323     BPatch_function *call9_func = bpfv[0];
1324  
1325     BPatch_Vector<BPatch_snippet *> call9_args;
1326
1327     BPatch_variableExpr *expr9_1 = appThread->malloc (*appImage->findType ("int"));
1328     BPatch_constExpr constExpr9_1 (0);
1329     BPatch_arithExpr arithexpr9_1 (BPatch_assign, *expr9_1, BPatch_constExpr (91));
1330     appThread->insertSnippet (arithexpr9_1, *point9_1);
1331
1332     if (mutateeFortran) {
1333         constExpr9_1 = expr9_1->getBaseAddr ();
1334     } else {
1335         constExpr9_1 = 91;
1336     }
1337
1338     call9_args.push_back(&constExpr9_1);
1339
1340     BPatch_variableExpr *expr9_2 = appThread->malloc (*appImage->findType ("int"));
1341     BPatch_constExpr constExpr9_2 (0);
1342     BPatch_arithExpr arithexpr9_2 (BPatch_assign, *expr9_2, BPatch_constExpr (92));
1343     appThread->insertSnippet (arithexpr9_2, *point9_1);
1344
1345     if (mutateeFortran) {
1346         constExpr9_2 = expr9_2->getBaseAddr ();
1347     } else {
1348         constExpr9_2 = 92;
1349     }
1350
1351     call9_args.push_back(&constExpr9_2);
1352
1353     BPatch_variableExpr *expr9_3 = appThread->malloc (*appImage->findType ("int"));
1354     BPatch_constExpr constExpr9_3 (0);
1355     BPatch_arithExpr arithexpr9_3 (BPatch_assign, *expr9_3, BPatch_constExpr (93));
1356     appThread->insertSnippet (arithexpr9_3, *point9_1);
1357
1358     if (mutateeFortran) {
1359         constExpr9_3 = expr9_3->getBaseAddr ();
1360     } else {
1361         constExpr9_3 = 93;
1362     }
1363
1364     call9_args.push_back(&constExpr9_3);
1365
1366     BPatch_variableExpr *expr9_4 = appThread->malloc (*appImage->findType ("int"));
1367     BPatch_constExpr constExpr9_4 (0);
1368     BPatch_arithExpr arithexpr9_4 (BPatch_assign, *expr9_4, BPatch_constExpr (94));
1369     appThread->insertSnippet (arithexpr9_4, *point9_1);
1370
1371     if (mutateeFortran) {
1372         constExpr9_4 = expr9_4->getBaseAddr ();
1373     } else {
1374         constExpr9_4 = 94;
1375     }
1376
1377     call9_args.push_back(&constExpr9_4);
1378
1379     BPatch_variableExpr *expr9_5 = appThread->malloc (*appImage->findType ("int"));
1380     BPatch_constExpr constExpr9_5 (0);
1381     BPatch_arithExpr arithexpr9_5 (BPatch_assign, *expr9_5, BPatch_constExpr (95));
1382     appThread->insertSnippet (arithexpr9_5, *point9_1);
1383
1384     if (mutateeFortran) {
1385         constExpr9_5 = expr9_5->getBaseAddr ();
1386     } else {
1387         constExpr9_5 = 95;
1388     }
1389
1390     call9_args.push_back(&constExpr9_5);
1391
1392     BPatch_funcCallExpr call9Expr(*call9_func, call9_args);
1393
1394     checkCost(call9Expr);
1395     appThread->insertSnippet(call9Expr, *point9_1, BPatch_callBefore, BPatch_lastSnippet);
1396 }
1397
1398 //
1399 // Start Test Case #10 - mutator side (insert snippet order)
1400 //
1401 void mutatorTest10(BPatch_thread *appThread, BPatch_image *appImage)
1402 {
1403     // Find the entry point to the procedure "func10_1"
1404   BPatch_Vector<BPatch_function *> found_funcs;
1405     if ((NULL == appImage->findFunction("func10_1", found_funcs)) || !found_funcs.size()) {
1406        fprintf(stderr, "    Unable to find function %s\n",
1407               "func10_1");
1408       exit(1);
1409     }
1410
1411     if (1 < found_funcs.size()) {
1412       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1413               __FILE__, __LINE__, found_funcs.size(), "func10_1");
1414     }
1415
1416     BPatch_Vector<BPatch_point *> *point10_1 = found_funcs[0]->findPoint(BPatch_entry);
1417
1418     if (!point10_1 || ((*point10_1).size() == 0)) {
1419         fprintf(stderr, "Unable to find entry point to \"func10_1\".\n");
1420         exit(1);
1421     }
1422
1423
1424     BPatch_Vector<BPatch_function *> bpfv;
1425     char *fn = "call10_1";
1426     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
1427         || NULL == bpfv[0]){
1428       fprintf(stderr, "    Unable to find function %s\n", fn);
1429       exit(1);
1430     }
1431
1432     BPatch_function *call10_1_func = bpfv[0];
1433     bpfv.clear();
1434
1435     char *fn2 = "call10_2";
1436     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
1437         || NULL == bpfv[0]){
1438       fprintf(stderr, "    Unable to find function %s\n", fn2);
1439       exit(1);
1440     }
1441
1442     BPatch_function *call10_2_func = bpfv[0];
1443     bpfv.clear();
1444
1445     char *fn3 = "call10_3";
1446     if (NULL == appImage->findFunction(fn3, bpfv) || !bpfv.size()
1447         || NULL == bpfv[0]){
1448       fprintf(stderr, "    Unable to find function %s\n", fn3);
1449       exit(1);
1450     }
1451
1452     BPatch_function *call10_3_func = bpfv[0];
1453   
1454     BPatch_Vector<BPatch_snippet *> nullArgs;
1455     BPatch_funcCallExpr call10_1Expr(*call10_1_func, nullArgs);
1456     BPatch_funcCallExpr call10_2Expr(*call10_2_func, nullArgs);
1457     BPatch_funcCallExpr call10_3Expr(*call10_3_func, nullArgs);
1458
1459     checkCost(call10_2Expr);
1460     appThread->insertSnippet( call10_2Expr, *point10_1);
1461
1462     checkCost(call10_1Expr);
1463     appThread->insertSnippet( call10_1Expr, *point10_1, BPatch_callBefore, 
1464                                                         BPatch_firstSnippet);
1465
1466     checkCost(call10_3Expr);
1467     appThread->insertSnippet( call10_3Expr, *point10_1, BPatch_callBefore, 
1468                                                         BPatch_lastSnippet);
1469 }
1470
1471 //
1472 // Start Test Case #11 - mutator side (snippets at entry,exit,call)
1473 //
1474 void mutatorTest11(BPatch_thread *appThread, BPatch_image *appImage)
1475 {
1476     // Find the entry point to the procedure "func11_1"
1477   BPatch_Vector<BPatch_function *> found_funcs;
1478     if ((NULL == appImage->findFunction("func11_1", found_funcs)) || !found_funcs.size()) {
1479       fprintf(stderr, "    Unable to find function %s\n",
1480               "func11_1");
1481       exit(1);
1482     }
1483
1484     if (1 < found_funcs.size()) {
1485       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1486               __FILE__, __LINE__, found_funcs.size(), "func11_1");
1487     }
1488
1489     BPatch_Vector<BPatch_point *> *point11_1 = found_funcs[0]->findPoint(BPatch_entry);
1490
1491     if (!point11_1 || (point11_1->size() < 1)) {
1492         fprintf(stderr, "Unable to find point func11_1 - entry.\n");
1493         exit(-1);
1494     }
1495
1496     // Find the subroutine points for the procedure "func11_1"
1497     BPatch_Vector<BPatch_point *> *point11_2 = found_funcs[0]->findPoint(BPatch_subroutine);
1498
1499     if (!point11_2 || (point11_2->size() < 1)) {
1500         fprintf(stderr, "Unable to find point func11_1 - calls.\n");
1501         exit(-1);
1502     }
1503
1504     // Find the exit point to the procedure "func11_1"
1505     BPatch_Vector<BPatch_point *> *point11_3 = found_funcs[0]->findPoint(BPatch_exit);
1506  
1507     if (!point11_3 || (point11_3->size() < 1)) {
1508         fprintf(stderr, "Unable to find point func11_1 - exit.\n");
1509         exit(-1);
1510     }
1511
1512
1513
1514     BPatch_Vector<BPatch_function *> bpfv;
1515     char *fn = "call11_1";
1516     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
1517         || NULL == bpfv[0]){
1518       fprintf(stderr, "    Unable to find function %s\n", fn);
1519       exit(1);
1520     }
1521
1522     BPatch_function *call11_1_func = bpfv[0];
1523     bpfv.clear();
1524
1525     char *fn2 = "call11_2";
1526     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
1527         || NULL == bpfv[0]){
1528       fprintf(stderr, "    Unable to find function %s\n", fn2);
1529       exit(1);
1530     }
1531
1532     BPatch_function *call11_2_func = bpfv[0];
1533     bpfv.clear();
1534
1535     char *fn3 = "call11_3";
1536     if (NULL == appImage->findFunction(fn3, bpfv) || !bpfv.size()
1537         || NULL == bpfv[0]){
1538       fprintf(stderr, "    Unable to find function %s\n", fn3);
1539       exit(1);
1540     }
1541     BPatch_function *call11_3_func = bpfv[0];
1542     bpfv.clear();
1543
1544     char *fn4 = "call11_4";
1545     if (NULL == appImage->findFunction(fn4, bpfv) || !bpfv.size()
1546         || NULL == bpfv[0]){
1547       fprintf(stderr, "    Unable to find function %s\n", fn4);
1548       exit(1);
1549     }
1550     BPatch_function *call11_4_func = bpfv[0];
1551
1552     BPatch_Vector<BPatch_snippet *> nullArgs;
1553     BPatch_funcCallExpr call11_1Expr(*call11_1_func, nullArgs);
1554     BPatch_funcCallExpr call11_2Expr(*call11_2_func, nullArgs);
1555     BPatch_funcCallExpr call11_3Expr(*call11_3_func, nullArgs);
1556     BPatch_funcCallExpr call11_4Expr(*call11_4_func, nullArgs);
1557
1558     checkCost(call11_1Expr);
1559     appThread->insertSnippet(call11_1Expr, *point11_1);
1560
1561     checkCost(call11_2Expr);
1562     appThread->insertSnippet(call11_2Expr, *point11_2, BPatch_callBefore);
1563
1564     checkCost(call11_3Expr);
1565     appThread->insertSnippet(call11_3Expr, *point11_2, BPatch_callAfter);
1566
1567     checkCost(call11_4Expr);
1568     appThread->insertSnippet(call11_4Expr, *point11_3);
1569 }
1570
1571 BPatchSnippetHandle *snippetHandle12_1;
1572 BPatch_variableExpr *varExpr12_1;
1573
1574 const int HEAP_TEST_UNIT_SIZE = 5000;
1575
1576 //
1577 // Start Test Case #12 - mutator side (insert/remove and malloc/free)
1578 //
1579 void mutatorTest12a(BPatch_thread *appThread, BPatch_image *appImage)
1580 {
1581     // Find the entry point to the procedure "func12_2"
1582     BPatch_Vector<BPatch_function *> found_funcs;
1583     if ((NULL == appImage->findFunction("func12_2", found_funcs)) || !found_funcs.size()) {
1584       fprintf(stderr, "    Unable to find function %s\n",
1585               "func12_2");
1586       exit(1);
1587     }
1588
1589     if (1 < found_funcs.size()) {
1590       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1591               __FILE__, __LINE__, found_funcs.size(), "func12_2");
1592     }
1593
1594     BPatch_Vector<BPatch_point *> *point12_2 = found_funcs[0]->findPoint(BPatch_entry);
1595
1596     if (!point12_2 || (point12_2->size() < 1)) {
1597         fprintf(stderr, "Unable to find point func12_2 - entry.\n");
1598         exit(-1);
1599     }
1600
1601     varExpr12_1 = appThread->malloc(100);
1602     if (!varExpr12_1) {
1603         fprintf(stderr, "Unable to allocate 100 bytes in mutatee\n");
1604         exit(-1);
1605     }
1606
1607     // Heap stress test - allocate memory until we run out, free it all
1608     //   and then allocate a small amount of memory.
1609     expectError = 66; // We're expecting a heap overflow error
1610     BPatch_variableExpr* memStuff[30000];
1611     BPatch_variableExpr *temp;
1612     int count;
1613     for (count = 0; count < 2000; count++) {
1614         temp = appThread->malloc(HEAP_TEST_UNIT_SIZE);
1615         if (!temp) {
1616             printf("*** Inferior malloc stress test failed\n"); 
1617             exit(-1);
1618         }
1619         memStuff[count] = temp;
1620     }
1621     expectError = DYNINST_NO_ERROR;
1622
1623     int freeCount = 0;
1624     for (int i =0; i < count; i++) {
1625         appThread->free(*memStuff[i]);
1626         freeCount++;
1627     }
1628
1629     temp = appThread->malloc(500); 
1630     if (!temp) {
1631         printf("*** Unable to allocate memory after using then freeing heap\n");
1632     }
1633
1634     BPatch_Vector<BPatch_function *> bpfv;
1635     char *fn = "call12_1";
1636     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || 
1637         NULL == bpfv[0]){
1638       fprintf(stderr, "    Unable to find function %s\n", fn);
1639       exit(1);
1640     }
1641
1642     BPatch_function *call12_1_func = bpfv[0];
1643
1644     BPatch_Vector<BPatch_snippet *> nullArgs;
1645     BPatch_funcCallExpr call12_1Expr(*call12_1_func, nullArgs);
1646
1647     checkCost(call12_1Expr);
1648     snippetHandle12_1 = appThread->insertSnippet(call12_1Expr, *point12_2);
1649     if (!snippetHandle12_1) {
1650             fprintf(stderr, "Unable to insert snippet to call function \"call12_1.\"\n");
1651         exit(-1);
1652     }
1653 }
1654
1655 void mutatorTest12b(BPatch_thread *appThread, BPatch_image * /*appImage*/)
1656 {
1657     waitUntilStopped(bpatch, appThread, 12, "insert/remove and malloc/free");
1658
1659     // remove instrumentation and free memory
1660     if (!appThread->deleteSnippet(snippetHandle12_1)) {
1661         printf("**Failed test #12 (insert/remove and malloc/free)\n");
1662         printf("    deleteSnippet returned an error\n");
1663         exit(-1);
1664     }
1665     appThread->free(*varExpr12_1);
1666
1667     // continue process
1668     appThread->continueExecution();
1669 }
1670
1671 //
1672 // Start Test Case #13 - mutator side (paramExpr,retExpr,nullExpr)
1673 //
1674 void mutatorTest13(BPatch_thread *appThread, BPatch_image *appImage)
1675 {
1676     // Find the entry point to the procedure "func13_1"
1677   BPatch_Vector<BPatch_function *> found_funcs;
1678     if ((NULL == appImage->findFunction("func13_1", found_funcs)) || !found_funcs.size()) {
1679       fprintf(stderr, "    Unable to find function %s\n",
1680               "func13_1");
1681       exit(1);
1682     }
1683
1684     if (1 < found_funcs.size()) {
1685       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1686               __FILE__, __LINE__, found_funcs.size(), "func13_1");
1687     }
1688
1689     BPatch_Vector<BPatch_point *> *point13_1 = found_funcs[0]->findPoint(BPatch_entry);
1690
1691     if (!point13_1 || (point13_1->size() < 1)) {
1692         fprintf(stderr, "Unable to find point func13_1 - entry.\n");
1693         exit(-1);
1694     }
1695
1696     BPatch_Vector<BPatch_function *> bpfv;
1697     char *fn = "call13_1";
1698     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
1699         || NULL == bpfv[0]){
1700       fprintf(stderr, "    Unable to find function %s\n", fn);
1701       exit(1);
1702     }
1703
1704     BPatch_function *call13_1_func = bpfv[0];
1705
1706     BPatch_Vector<BPatch_snippet *> funcArgs;
1707
1708     funcArgs.push_back(new BPatch_paramExpr(0));
1709     funcArgs.push_back(new BPatch_paramExpr(1));
1710     funcArgs.push_back(new BPatch_paramExpr(2));
1711     funcArgs.push_back(new BPatch_paramExpr(3));
1712     funcArgs.push_back(new BPatch_paramExpr(4));
1713     BPatch_funcCallExpr call13_1Expr(*call13_1_func, funcArgs);
1714
1715     checkCost(call13_1Expr);
1716     appThread->insertSnippet(call13_1Expr, *point13_1);
1717
1718     BPatch_nullExpr call13_2Expr;
1719     checkCost(call13_2Expr);
1720     appThread->insertSnippet(call13_2Expr, *point13_1);
1721
1722     // now test that a return value can be read.
1723     BPatch_Vector<BPatch_function *> found_funcs2;
1724     if ((NULL == appImage->findFunction("func13_2", found_funcs2)) || !found_funcs2.size()) {
1725         fprintf(stderr, "    Unable to find function %s\n",
1726               "func13_2");
1727       exit(1);
1728     }
1729
1730     if (1 < found_funcs2.size()) {
1731       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1732               __FILE__, __LINE__, found_funcs2.size(), "func13_2");
1733     }
1734
1735     BPatch_Vector<BPatch_point *> *point13_2 = found_funcs2[0]->findPoint(BPatch_exit);
1736
1737     if (!point13_2 || (point13_2->size() < 1)) {
1738         fprintf(stderr, "Unable to find point func13_2 - exit.\n");
1739         exit(-1);
1740     }
1741
1742     bpfv.clear();
1743
1744     char *fn2 = "call13_2";
1745     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
1746         || NULL == bpfv[0]){
1747       fprintf(stderr, "    Unable to find function %s\n", fn2);
1748       exit(1);
1749     }
1750
1751     BPatch_function *call13_2_func = bpfv[0];
1752
1753     BPatch_Vector<BPatch_snippet *> funcArgs2;
1754
1755     BPatch_variableExpr *expr13_1;
1756     BPatch_retExpr *ret_var;
1757     BPatch_constExpr expr13_2 (0);
1758
1759     if (mutateeFortran) {
1760         expr13_1 = appThread->malloc (*appImage->findType ("int"));
1761         ret_var = new BPatch_retExpr();
1762         BPatch_arithExpr test_arith (BPatch_assign, *expr13_1, *ret_var);
1763         appThread->insertSnippet (test_arith, *point13_2);
1764         expr13_2 = expr13_1->getBaseAddr ();
1765         funcArgs2.push_back (&expr13_2);
1766     } else {
1767         funcArgs2.push_back(new BPatch_retExpr());
1768     }
1769
1770     BPatch_funcCallExpr call13_3Expr(*call13_2_func, funcArgs2);
1771
1772     checkCost(call13_1Expr);
1773     appThread->insertSnippet(call13_3Expr, *point13_2, BPatch_callAfter, BPatch_lastSnippet);
1774 }
1775
1776 //
1777 // Start Test Case #14 - mutator side (replace function call)
1778 //
1779 void mutatorTest14(BPatch_thread *appThread, BPatch_image *appImage)
1780 {
1781     replaceFunctionCalls(appThread, appImage, "func14_1", "func14_2", "call14_1", 
1782         14, "replace/remove function call", 1);
1783     replaceFunctionCalls(appThread, appImage, "func14_1", "func14_3", NULL,
1784         14, "replace/remove function call", 1);
1785 }
1786
1787 //
1788 // Start Test Case #15 - mutator side (setMutationsActive)
1789 //
1790 void mutatorTest15a(BPatch_thread *appThread, BPatch_image *appImage)
1791 {
1792     insertCallSnippetAt(appThread, appImage, "func15_2", BPatch_entry,
1793             "call15_1", 15, "setMutationsActive");
1794     /*
1795 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
1796     // On the Sparc, functions containing system calls are relocated into the
1797     // heap when instrumented, making a special case we should check.
1798
1799     // "access" makes the "access" system call, so we'll instrument it
1800     insertCallSnippetAt(appThread, appImage, "access", BPatch_entry,
1801         "call15_2", 15, "setMutationsActive");
1802
1803     // We want to instrument more than one point, so do exit as well
1804     insertCallSnippetAt(appThread, appImage, "access", BPatch_exit,
1805         "call15_2", 15, "setMutationsActive");
1806 #endif
1807     */
1808     replaceFunctionCalls(appThread, appImage, "func15_4", "func15_3",
1809         "call15_3", 15, "setMutationsActive", 1);
1810 }
1811
1812 void mutatorTest15b(BPatch_thread *appThread, BPatch_image * /*appImage*/)
1813 {
1814     waitUntilStopped(bpatch, appThread, 15, "setMutationsActive");
1815
1816     // disable mutations and continue process
1817     appThread->setMutationsActive(false);
1818     appThread->continueExecution();
1819     
1820     waitUntilStopped(bpatch, appThread, 15, "setMutationsActive");
1821
1822     // re-enable mutations and continue process
1823     appThread->setMutationsActive(true);
1824     appThread->continueExecution();
1825 }
1826
1827 BPatch_Vector<BPatch_snippet *> genLongExpr(BPatch_arithExpr *tail)
1828 {
1829     BPatch_Vector<BPatch_snippet *> ret;
1830     
1831     for (int i=0; i < 1000; i++) {
1832         ret.push_back(tail);
1833     }
1834     return ret;
1835 }
1836
1837 //
1838 // Start Test Case #16 - mutator side (if-else)
1839 //
1840 void mutatorTest16(BPatch_thread *appThread, BPatch_image *appImage)
1841 {
1842
1843   BPatch_Vector<BPatch_function *> found_funcs;
1844     if ((NULL == appImage->findFunction("func16_1", found_funcs)) || !found_funcs.size()) {
1845       fprintf(stderr, "    Unable to find function %s\n",
1846               "func16_1");
1847       exit(1);
1848     }
1849
1850     if (1 < found_funcs.size()) {
1851       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1852               __FILE__, __LINE__, found_funcs.size(), "func16_1");
1853     }
1854
1855     BPatch_Vector<BPatch_point *> *func16_1 = found_funcs[0]->findPoint(BPatch_subroutine);
1856
1857     if (!func16_1 || ((*func16_1).size() == 0)) {
1858         fprintf(stderr, "Unable to find entry point to \"func16_1\".\n");
1859         exit(1);
1860     }
1861
1862     BPatch_variableExpr *expr16_1, *expr16_2, *expr16_3, *expr16_4, *expr16_5,
1863         *expr16_6, *expr16_7, *expr16_8, *expr16_9, *expr16_10;
1864
1865     expr16_1 = findVariable(appImage, "globalVariable16_1", func16_1);
1866     expr16_2 = findVariable(appImage, "globalVariable16_2", func16_1);
1867     expr16_3 = findVariable(appImage, "globalVariable16_3", func16_1);
1868     expr16_4 = findVariable(appImage, "globalVariable16_4", func16_1);
1869     expr16_5 = findVariable(appImage, "globalVariable16_5", func16_1);
1870     expr16_6 = findVariable(appImage, "globalVariable16_6", func16_1);
1871     expr16_7 = findVariable(appImage, "globalVariable16_7", func16_1);
1872     expr16_8 = findVariable(appImage, "globalVariable16_8", func16_1);
1873     expr16_9 = findVariable(appImage, "globalVariable16_9", func16_1);
1874     expr16_10 = findVariable(appImage, "globalVariable16_10", func16_1);
1875
1876     if (!expr16_1 || !expr16_2 || !expr16_3 || !expr16_4 || !expr16_5 ||
1877         !expr16_6 || !expr16_7 || !expr16_8 || !expr16_9 || !expr16_10) {
1878         fprintf(stderr, "**Failed** test #16 (if-else)\n");
1879         fprintf(stderr, "    Unable to locate one of globalVariable16_?\n");
1880         exit(1);
1881     }
1882
1883     BPatch_arithExpr assign16_1(BPatch_assign, *expr16_1, BPatch_constExpr(1));
1884     BPatch_arithExpr assign16_2(BPatch_assign, *expr16_2, BPatch_constExpr(1));
1885
1886     BPatch_ifExpr if16_2(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(1),
1887         BPatch_constExpr(1)), assign16_1, assign16_2);
1888
1889     BPatch_arithExpr assign16_3(BPatch_assign, *expr16_3, BPatch_constExpr(1));
1890     BPatch_arithExpr assign16_4(BPatch_assign, *expr16_4, BPatch_constExpr(1));
1891
1892     BPatch_ifExpr if16_3(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0),
1893         BPatch_constExpr(1)), assign16_3, assign16_4);
1894
1895     BPatch_arithExpr assign16_5(BPatch_assign, *expr16_5, BPatch_constExpr(1));
1896     BPatch_arithExpr assign16_6(BPatch_assign, *expr16_6, BPatch_constExpr(1));
1897     BPatch_sequence longExpr16_1(genLongExpr(&assign16_5));
1898
1899
1900     BPatch_ifExpr if16_4(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0),
1901         BPatch_constExpr(1)), longExpr16_1, assign16_6);
1902
1903     BPatch_arithExpr assign16_7(BPatch_assign, *expr16_7, BPatch_constExpr(1));
1904     BPatch_arithExpr assign16_8(BPatch_assign, *expr16_8, BPatch_constExpr(1));
1905     BPatch_sequence longExpr16_2(genLongExpr(&assign16_8));
1906
1907     BPatch_ifExpr if16_5(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0),
1908         BPatch_constExpr(1)), assign16_7, longExpr16_2);
1909
1910     BPatch_arithExpr assign16_9(BPatch_assign, *expr16_9, BPatch_constExpr(1));
1911     BPatch_arithExpr assign16_10(BPatch_assign, *expr16_10,BPatch_constExpr(1));
1912     BPatch_sequence longExpr16_3(genLongExpr(&assign16_9));
1913     BPatch_sequence longExpr16_4(genLongExpr(&assign16_10));
1914
1915     BPatch_ifExpr if16_6(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0),
1916         BPatch_constExpr(1)), longExpr16_3, longExpr16_4);
1917
1918     insertSnippetAt(appThread, appImage, "func16_2", BPatch_entry, if16_2,
1919         16, "if-else");
1920     insertSnippetAt(appThread, appImage, "func16_3", BPatch_entry, if16_3,
1921         16, "if-else");
1922     insertSnippetAt(appThread, appImage, "func16_4", BPatch_entry, if16_4,
1923         16, "if-else");
1924     insertSnippetAt(appThread, appImage, "func16_4", BPatch_entry, if16_5,
1925         16, "if-else");
1926     insertSnippetAt(appThread, appImage, "func16_4", BPatch_entry, if16_6,
1927         16, "if-else");
1928 }
1929
1930 //
1931 // Start Test Case #17 - mutator side (return values from func calls)
1932 // Verify that instrumentation inserted at a subroutine's exit point
1933 // doesn't clobber its return value.
1934 // Method: the mutatee's func17_1 (first and only) exit is instrumented to
1935 // call call17_1 with parameter (constant) "1"; func17_2's (first and only)
1936 // exit is similarly instrumented to call call17_2(1); a subsequent test in
1937 // the mutatee compares the return values of func17_1 and func17_2.
1938 // (No examination is made of the return values of call17_1 or call17_2.)
1939 //
1940 void mutatorTest17(BPatch_thread *appThread, BPatch_image *appImage)
1941 {
1942     // Find the entry point to the procedure "func17_1"
1943   BPatch_Vector<BPatch_function *> found_funcs;
1944     if ((NULL == appImage->findFunction("func17_1", found_funcs)) || !found_funcs.size()) {
1945        fprintf(stderr, "    Unable to find function %s\n",
1946               "func17_1");
1947       exit(1);
1948     }
1949
1950     if (1 < found_funcs.size()) {
1951       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
1952               __FILE__, __LINE__, found_funcs.size(), "func17_1");
1953     }
1954
1955     BPatch_Vector<BPatch_point *> *point17_1 = found_funcs[0]->findPoint(BPatch_exit);
1956
1957     if (!point17_1 || (point17_1->size() < 1)) {
1958         fprintf(stderr, "Unable to find point func17_1 - exit.\n");
1959         exit(-1);
1960     }
1961
1962     BPatch_Vector<BPatch_function *> bpfv;
1963     char *fn = "call17_1";
1964     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
1965         || NULL == bpfv[0]){
1966       fprintf(stderr, "    Unable to find function %s\n", fn);
1967       exit(1);
1968     }
1969
1970     BPatch_function *call17_1_func = bpfv[0];
1971
1972     BPatch_Vector<BPatch_snippet *> funcArgs;
1973
1974     BPatch_variableExpr *var17_1 = appThread->malloc (*appImage->findType ("int"));
1975     BPatch_constExpr constExpr17_1 (0);
1976     BPatch_arithExpr arithExpr17_1 (BPatch_assign, *var17_1, BPatch_constExpr (1));
1977     appThread->insertSnippet (arithExpr17_1, *point17_1);
1978
1979     if (mutateeFortran) {
1980         constExpr17_1 = var17_1->getBaseAddr ();
1981     } else {
1982         constExpr17_1 = 1;
1983     }
1984
1985     funcArgs.push_back (&constExpr17_1);
1986
1987     BPatch_funcCallExpr call17_1Expr(*call17_1_func, funcArgs);
1988     checkCost(call17_1Expr);
1989     appThread->insertSnippet(call17_1Expr, *point17_1, BPatch_callAfter, BPatch_lastSnippet);
1990
1991     // Find the exit point to the procedure "func17_2"
1992     BPatch_Vector<BPatch_function *> found_funcs2;
1993     if ((NULL == appImage->findFunction("func17_2", found_funcs2)) || !found_funcs2.size()) {
1994       fprintf(stderr, "    Unable to find function %s\n",
1995               "func17_2");
1996       exit(1);
1997     }
1998
1999     if (1 < found_funcs2.size()) {
2000       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
2001               __FILE__, __LINE__, found_funcs2.size(), "func17_2");
2002     }
2003
2004     BPatch_Vector<BPatch_point *> *point17_2 = found_funcs2[0]->findPoint(BPatch_exit);
2005
2006     if (!point17_2 || (point17_2->size() < 1)) {
2007         fprintf(stderr, "Unable to find point func17_2 - exit.\n");
2008         exit(-1);
2009     }
2010
2011     bpfv.clear();
2012     char *fn2 = "call17_2";
2013     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
2014         || NULL == bpfv[0]){
2015       fprintf(stderr, "    Unable to find function %s\n", fn2);
2016       exit(1);
2017     }
2018
2019     BPatch_function *call17_2_func = bpfv[0];
2020
2021     BPatch_Vector<BPatch_snippet *> funcArgs2;
2022
2023     BPatch_variableExpr *var17_2 = appThread->malloc (*appImage->findType ("int"));
2024     BPatch_constExpr constExpr17_2 (0);
2025     BPatch_arithExpr arith17_2 (BPatch_assign, *var17_2, BPatch_constExpr (1));
2026     appThread->insertSnippet (arith17_2, *point17_2);
2027
2028     if (mutateeFortran) {
2029         constExpr17_2 = var17_2->getBaseAddr ();
2030     } else {
2031         constExpr17_2 = 1;
2032     }
2033
2034     funcArgs2.push_back (&constExpr17_2);
2035
2036     BPatch_funcCallExpr call17_2Expr(*call17_2_func, funcArgs2);
2037     checkCost(call17_2Expr);
2038
2039     // test interface to call into insertSnippet with only one parameter
2040     BPatch_point &aPoint = *(*point17_2)[0];
2041     appThread->insertSnippet(call17_2Expr, aPoint, BPatch_callAfter, BPatch_lastSnippet);
2042 }
2043
2044 //
2045 // Start Test Case #18 - mutator side (read/write a variable in the mutatee)
2046 //
2047 void mutatorTest18(BPatch_thread *appThread, BPatch_image *appImage)
2048 {
2049   BPatch_Vector<BPatch_function *> found_funcs;
2050     if ((NULL == appImage->findFunction("func18_1", found_funcs)) || !found_funcs.size()) {
2051       fprintf(stderr, "    Unable to find function %s\n",
2052               "func18_1");
2053       exit(1);
2054     }
2055
2056     if (1 < found_funcs.size()) {
2057       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
2058               __FILE__, __LINE__, found_funcs.size(), "func18_1");
2059     }
2060
2061     BPatch_Vector<BPatch_point *> *func18_1 = found_funcs[0]->findPoint(BPatch_subroutine);
2062
2063     if (!func18_1 || ((*func18_1).size() == 0)) {
2064         fprintf(stderr, "Unable to find entry point to \"func18_1\".\n");
2065         exit(1);
2066     }
2067
2068     BPatch_variableExpr *expr18_1 = findVariable(appImage, "globalVariable18_1", func18_1);
2069
2070 /* Initialization must be done, because C would have done initialization at declaration */
2071     if (mutateeFortran) {
2072         BPatch_arithExpr arith18_1 (BPatch_assign, *expr18_1, BPatch_constExpr (42));
2073         appThread->oneTimeCode (arith18_1);
2074     }
2075
2076     if (expr18_1 == NULL) {
2077         fprintf(stderr, "**Failed** test #18 (read/write a variable in the mutatee)\n");
2078         fprintf(stderr, "    Unable to locate globalVariable18_1\n");
2079         exit(1);
2080     }
2081
2082     int n;
2083     expr18_1->readValue(&n);
2084
2085     if (n != 42) {
2086         fprintf(stderr, "**Failed** test #18 (read/write a variable in the mutatee)\n");
2087         fprintf(stderr, "    value read from globalVariable18_1 was %d, not 42 as expected\n", n);
2088         exit(1);
2089     }
2090
2091     n = 17;
2092     expr18_1->writeValue(&n,true); //ccw 31 jul 2002
2093 }
2094
2095 void test19_oneTimeCodeCallback(BPatch_thread * /*thread*/,
2096                                 void *userData,
2097                                 void * /*returnValue*/)
2098 {
2099    *(int *)userData = 1;
2100 }
2101
2102 //
2103 // Start Test Case #19 - mutator side (oneTimeCode)
2104 //
2105 void mutatorTest19(BPatch_thread *appThread, BPatch_image *appImage)
2106 {
2107     waitUntilStopped(bpatch, appThread, 19, "oneTimeCode");
2108
2109     BPatch_Vector<BPatch_function *> bpfv;
2110     char *fn = "call19_1";
2111     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
2112         || NULL == bpfv[0]){
2113       fprintf(stderr, "    Unable to find function %s\n", fn);
2114       exit(1);
2115     }
2116
2117     BPatch_function *call19_1_func = bpfv[0];
2118
2119     BPatch_Vector<BPatch_snippet *> nullArgs;
2120     BPatch_funcCallExpr call19_1Expr(*call19_1_func, nullArgs);
2121     checkCost(call19_1Expr);
2122
2123     appThread->oneTimeCode(call19_1Expr);
2124
2125     // Let the mutatee run to check the result
2126     appThread->continueExecution();
2127
2128     // Wait for the next test
2129     waitUntilStopped(bpatch, appThread, 19, "oneTimeCode");
2130
2131     bpfv.clear();
2132     char *fn2 = "call19_2";
2133     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
2134         || NULL == bpfv[0]){
2135       fprintf(stderr, "    Unable to find function %s\n", fn2);
2136       exit(1);
2137     }
2138
2139     BPatch_function *call19_2_func = bpfv[0];
2140
2141     BPatch_funcCallExpr call19_2Expr(*call19_2_func, nullArgs);
2142     checkCost(call19_2Expr);
2143
2144     int callbackFlag = 0;
2145
2146     // Register a callback that will set the flag callbackFlag
2147     BPatchOneTimeCodeCallback oldCallback = 
2148         bpatch->registerOneTimeCodeCallback(test19_oneTimeCodeCallback);
2149
2150     appThread->oneTimeCodeAsync(call19_2Expr, (void *)&callbackFlag);
2151
2152     // Async leaves the process in its previous state...
2153     appThread->continueExecution();
2154
2155     // Wait for the callback to be called
2156     while (!appThread->isTerminated() && !callbackFlag) ;
2157
2158     // Restore old callback (if there was one)
2159     bpatch->registerOneTimeCodeCallback(oldCallback);
2160
2161     // Let the mutatee run to check the result and then go on to the next test
2162     appThread->continueExecution();
2163 }
2164
2165 //
2166 // Start Test Case #20 - mutator side (instrumentation at arbitrary points)
2167 //
2168 void mutatorTest20(BPatch_thread *appThread, BPatch_image *appImage)
2169 {
2170     BPatch_Vector<BPatch_function *> bpfv;
2171     char *fn = "call20_1";
2172     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
2173         || NULL == bpfv[0]){
2174         fprintf(stderr, "    Unable to find function %s\n", fn);
2175         exit(1);
2176     }
2177
2178
2179
2180     BPatch_function *call20_1_func = bpfv[0];
2181
2182     BPatch_Vector<BPatch_snippet *> nullArgs;
2183     BPatch_funcCallExpr call20_1Expr(*call20_1_func, nullArgs);
2184
2185     checkCost(call20_1Expr);
2186
2187     bpfv.clear();
2188     char *fn2 = "func20_2";
2189     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
2190         || NULL == bpfv[0]){
2191       fprintf(stderr, "    Unable to find function %s\n", fn2);
2192       exit(1);
2193     }
2194
2195     BPatch_function *f = bpfv[0];
2196
2197     // We really don't want to use function size... grab a flowgraph and
2198     // do this right.
2199     BPatch_flowGraph *cfg = f->getCFG();
2200     if (!cfg) {
2201         fprintf(stderr, "**Failed** test #20 (instrumentation at arbitrary points)\n");
2202         fprintf(stderr, "    no flowgraph for function 20_2\n");
2203         exit(1);
2204     }
2205
2206     BPatch_point *p = NULL;
2207     bool found_one = false;
2208
2209     /* We expect certain errors from createInstPointAtAddr. */
2210     BPatchErrorCallback oldError =
2211         bpatch->registerErrorCallback(createInstPointError);
2212
2213     BPatch_Set<BPatch_basicBlock *> blocks;
2214     if (!cfg->getAllBasicBlocks(blocks))
2215         assert(0); // This can't return false :)
2216     if (blocks.size() == 0) {
2217         fprintf(stderr, "**Failed** test #20 (instrumentation at arbitrary points)\n");
2218         fprintf(stderr, "    no blocks for function 20_2\n");
2219         exit(1);
2220     }
2221     
2222     appThread->getProcess()->beginInsertionSet();
2223
2224     dprintf("%s[%d]:  about to instrument %d basic blocks\n", __FILE__, __LINE__, blocks.size());
2225     BPatch_Set<BPatch_basicBlock *>::iterator blockIter = blocks.begin();
2226     for (; blockIter != blocks.end(); blockIter++) {
2227         BPatch_basicBlock *block = *blockIter;
2228         assert(block);
2229
2230         dprintf("%s[%d]:  inserting arbitrary instrumentation in basic block starting at addr %p\n", __FILE__, __LINE__, (void *) block->getStartAddress());
2231         BPatch_Vector<BPatch_instruction *> *insns = block->getInstructions();
2232         assert(insns);
2233         BPatch_point *oldPt = NULL;
2234         for (unsigned int i = 0; i < insns->size(); ++i) {
2235           BPatch_instruction *insn = (*insns)[i];
2236           BPatch_point *pt = insn->getInstPoint();
2237           if (pt == oldPt) continue; 
2238
2239           if (pt) {
2240             if (pt->getPointType() == BPatch_arbitrary) {
2241                 found_one = true;
2242                 if (appThread->insertSnippet(call20_1Expr, *pt) == NULL) {
2243                     fprintf(stderr,
2244                             "%s[%d]: Unable to insert snippet into function \"func20_2.\"\n",
2245                              __FILE__, __LINE__);
2246                     exit(1);
2247                 }
2248                 dprintf("%s[%d]:  SUCCESS installing inst at address %p/%p\n", __FILE__, __LINE__, insn->getAddress(), pt->getAddress());
2249                 oldPt = pt;
2250             }
2251             else 
2252               fprintf(stderr, "%s[%d]:  non-arbitrary point being ignored\n", __FILE__, __LINE__);
2253
2254           }
2255           else {
2256              fprintf(stderr, "%s[%d]:  no instruction for point\n", __FILE__, __LINE__);
2257           }
2258         }
2259     }
2260     appThread->getProcess()->finalizeInsertionSet(false);
2261
2262     dprintf("%s[%d]: instrumented  %d basic blocks\n", __FILE__, __LINE__, blocks.size());
2263
2264     bpatch->registerErrorCallback(oldError);
2265
2266     if (!found_one) {
2267         fprintf(stderr, "Unable to find a point to instrument in function \"func20_2.\"\n");
2268         exit(1);
2269     }
2270 }
2271
2272
2273 //
2274 // Start Test Case #21 - mutator side (findFunction in module)
2275 //
2276 // There is no corresponding failure (test2) testing because the only
2277 // bad input to replaceFunction is a non-existent BPatch_function.
2278 // But this is already checked by the "non-existent function" test in
2279 // test2.
2280
2281 void readyTest21or22(BPatch_thread *appThread)
2282 {
2283     char libA[128], libB[128];
2284     sprintf(libA, "%s", libNameA);
2285     sprintf(libB, "%s", libNameB);
2286 #if !defined(i386_unknown_nt4_0)
2287     if (!mutateeFortran) {
2288         if (! appThread->loadLibrary(libA)) {
2289              fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2290              fprintf(stderr, "  Mutator couldn't load %s into mutatee\n", libNameA);
2291              exit(1);
2292         }
2293         if (! appThread->loadLibrary(libB)) {
2294              fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2295              fprintf(stderr, "  Mutator couldn't load %s into mutatee\n", libNameB);
2296              exit(1);
2297         }
2298     }
2299 #endif
2300 }
2301
2302 void mutatorTest21(BPatch_thread *, BPatch_image *appImage)
2303 {
2304 #if defined(sparc_sun_solaris2_4) \
2305  || defined(alpha_dec_osf4_0) \
2306  || defined(i386_unknown_solaris2_5) \
2307  || defined(i386_unknown_linux2_0) \
2308  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
2309  || defined(ia64_unknown_linux2_4) \
2310  || defined(mips_sgi_irix6_4) \
2311  || defined(rs6000_ibm_aix4_1) \
2312  || defined(ppc64_linux)
2313
2314     // Lookup the libtestA.so and libtestB.so modules that we've just loaded
2315
2316     if (mutateeFortran) {
2317         return;
2318     }
2319
2320     BPatch_module *modA = NULL;
2321     BPatch_module *modB = NULL;
2322     BPatch_Vector<BPatch_module *> *mods = appImage->getModules();
2323     if (!mods || mods->size() == 0) {
2324          fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2325          fprintf(stderr, "  Mutator couldn't search modules of mutatee\n");
2326          exit(1);
2327     }
2328
2329     for (unsigned int i = 0; i < mods->size() && !(modA && modB); i++) {
2330          char buf[1024];
2331          BPatch_module *m = (*mods)[i];
2332          m->getName(buf, 1024);
2333          // module names sometimes have "_module" appended
2334          if (!strncmp(libNameA, buf, strlen(libNameA)))
2335               modA = m;
2336          else if (!strncmp(libNameB, buf, strlen(libNameB)))
2337               modB = m;
2338     }
2339     if (! modA || ! modB ) {
2340          fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2341          fprintf(stderr, "  Mutator couldn't find shlib in mutatee\n");
2342          for (unsigned int j = 0; j < mods->size(); ++j) {
2343             char buf2[1024];
2344             BPatch_module *m = (*mods)[j];
2345             m->getName(buf2, 1024);
2346             fprintf(stderr, "%s[%d]:  module: %s\n", __FILE__, __LINE__, buf2);
2347          }
2348          fflush(stdout);
2349          exit(1);
2350     }
2351
2352     // Find the function CALL21_1 in each of the modules
2353     BPatch_Vector<BPatch_function *> bpmv;
2354     if (NULL == modA->findFunction("call21_1", bpmv, false, false, true) || !bpmv.size()) {
2355       fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2356       fprintf(stderr, "  %s[%d]: Mutator couldn't find a function in %s\n", 
2357                          __FILE__, __LINE__, libNameA);
2358       exit(1);
2359     }
2360     BPatch_function *funcA = bpmv[0];
2361
2362     bpmv.clear();
2363     if (NULL == modB->findFunction("call21_1", bpmv, false, false, true) || !bpmv.size()) {
2364       fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2365       fprintf(stderr, "  %s[%d]: Mutator couldn't find a function in %s\n", 
2366                           __FILE__, __LINE__, libNameB);
2367       exit(1);
2368     } 
2369     BPatch_function *funcB = bpmv[0];
2370
2371     // Kludgily test whether the functions are distinct
2372     if (funcA->getBaseAddr() == funcB->getBaseAddr()) {
2373          fprintf(stderr, "**Failed test #21 (findFunction in module)\n");
2374          fprintf(stderr,
2375                 "  Mutator cannot distinguish two functions from different shlibs\n");
2376          exit(1);
2377     }
2378
2379     //  Now test regex search
2380     //  Not meant to be an extensive check of all regex usage, just that
2381     //  the basic mechanism that deals with regexes is not broken
2382
2383     bpmv.clear();
2384     //   regex "^cb" should match all functions that begin with "cb"
2385     //   We dont use existing "call" functions here since (at least on
2386     //   linux, we also find call_gmon_start().  Thus the dummy fns.
2387     if (NULL == modB->findFunction("^cb", bpmv, false, false, true) || (bpmv.size() != 2)) {
2388
2389          fprintf(stderr, "**Failed test #21 (findFunction in module, regex)\n");
2390          fprintf(stderr, "  Expected 2 functions matching ^cb, got %d\n",
2391                             bpmv.size());
2392          char buf[128];
2393          for (unsigned int i = 0; i < bpmv.size(); ++i) 
2394             fprintf(stderr, "  matched function: %s\n", 
2395                    bpmv[i]->getName(buf, 128));
2396          exit(1);
2397     }
2398
2399     bpmv.clear();
2400     if (NULL == modB->findFunction("^cbll21", bpmv, false, false, true) || (bpmv.size() != 1)) {
2401          fprintf(stderr, "**Failed test #21 (findFunction in module, regex)\n");
2402          fprintf(stderr, "  Expected 1 function matching ^cbll21, got %d\n",
2403                             bpmv.size());
2404          exit(1);
2405     }
2406 #endif
2407 }
2408
2409
2410 //
2411 // Start Test Case #22 - mutator side (replace function)
2412 //
2413 // There is no corresponding failure (test2) testing because the only
2414 // invalid input to replaceFunction is a non-existent BPatch_function.
2415 // But this is already checked by the "non-existent function" test in
2416 // test2.
2417 void mutatorTest22(BPatch_thread *appThread, BPatch_image *appImage)
2418 {
2419 #if defined(sparc_sun_solaris2_4) \
2420  || defined(i386_unknown_linux2_0) \
2421  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
2422  || defined(alpha_dec_osf4_0) \
2423  || defined(ia64_unknown_linux2_4) \
2424  || defined(ppc64_linux)
2425
2426     if (mutateeFortran) {
2427         return;
2428     }
2429
2430     char errbuf[1024]; errbuf[0] = '\0';
2431     BPatch_module *modA = NULL;
2432     BPatch_module *modB = NULL;
2433
2434     // Assume that a prior test (mutatorTest21) has loaded the
2435     // libraries libtestA.so and libtestB.so into the mutator.
2436     BPatch_Vector<BPatch_module *> *mods = appImage->getModules();
2437     if (!mods || mods->size() == 0) {
2438          fprintf(stderr, "**Failed test #22 (replace function)\n");
2439          fprintf(stderr, "  Mutator couldn't find shlib in mutatee\n");
2440          exit(1);
2441     }
2442     // Lookup the libtestA.so and libtestB.so modules
2443     for (unsigned int i = 0; i < mods->size() && !(modA && modB); i++) {
2444          char buf[1024];
2445          BPatch_module *m = (*mods)[i];
2446          m->getName(buf, 1024);
2447          // module names sometimes have "_module" appended
2448          if (!strncmp(libNameA, buf, strlen(libNameA)))
2449               modA = m;
2450          else if (!strncmp(libNameB, buf, strlen(libNameB)))
2451               modB = m;
2452     }
2453     if (! modA || ! modB) {
2454          fprintf(stderr, "**Failed test #22 (replace function)\n");
2455          fprintf(stderr, "  Mutator couldn't find dynamically loaded modules\n");
2456          exit(1);
2457     }
2458     
2459     //  Mutatee function replacement scheme:
2460
2461     //  function      module     replaced    global
2462     //                         or called?   
2463
2464     //  call22_1       a.out     replaced         1       global is the index
2465     //  call22_2       a.out       called         1       of the global variable
2466     //  call22_3       a.out     replaced         2       in test1.mutatee updated
2467     //  call22_4    libtestA       called         2       by the function
2468     //  call22_5A   libtestA     replaced         3
2469     //  call22_5B   libtestB       called         3
2470     //  call22_6    libtestA     replaced         4
2471     //  call22_7       a.out       called         4
2472
2473     // Both of each pair of functions (e.g., call22_1, call22_2)
2474     // increments a global variable.  The mutatee will test that the
2475     // variable has been updated only be the "called" function.
2476
2477     // Replace an a.out with another a.out function
2478
2479     BPatch_Vector<BPatch_function *> bpfv;
2480     char *fn = "call22_1";
2481     char *fn2 = "call22_2";
2482
2483     if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
2484         || NULL == bpfv[0]){
2485       fprintf(stderr, "**Failed test #22 (replace function)\n");
2486       fprintf(stderr, "    Unable to find function %s\n", fn);
2487       exit(1);
2488     }
2489
2490     BPatch_function *call22_1func = bpfv[0];
2491
2492     bpfv.clear();
2493     if (NULL == appImage->findFunction(fn2, bpfv) || !bpfv.size()
2494         || NULL == bpfv[0]){
2495       fprintf(stderr, "**Failed test #22 (replace function)\n");
2496       fprintf(stderr, "    Unable to find function %s\n", fn2);
2497       exit(1);
2498     }
2499
2500     BPatch_function *call22_2func = bpfv[0];
2501
2502     if (! appThread->replaceFunction(*call22_1func, *call22_2func)) {
2503          fprintf(stderr, "**Failed test #22 (replace function)\n");
2504          fprintf(stderr, "  Mutator couldn't replaceFunction (a.out -> a.out)\n");
2505          exit(1);
2506     }
2507
2508     // Replace an a.out function with a shlib function
2509     bpfv.clear();
2510     char *fn3 = "call22_3";
2511     if (NULL == appImage->findFunction(fn3, bpfv) || !bpfv.size()
2512         || NULL == bpfv[0]){
2513       fprintf(stderr, "**Failed test #22 (replace function)\n");
2514       fprintf(stderr, "    Unable to find function %s\n", fn3);
2515       exit(1);
2516     }
2517
2518     BPatch_function *call22_3func = bpfv[0];
2519
2520     BPatch_Vector<BPatch_function *> bpmv;
2521     if (NULL == modA->findFunction("call22_4", bpmv) || !bpmv.size()) {
2522          fprintf(stderr, "**Failed test #22 (replace function)\n");
2523          fprintf(stderr, "  Mutator couldn't find functions in mutatee\n");
2524          exit(1);
2525     }
2526     BPatch_function *call22_4func = bpmv[0];
2527     
2528     if (! appThread->replaceFunction(*call22_3func, *call22_4func)) {
2529          fprintf(stderr, "**Failed test #22 (replace function)\n");
2530          fprintf(stderr, "  Mutator couldn't replaceFunction (a.out -> shlib)\n");
2531          exit(1);
2532     }
2533
2534     // Replace a shlib function with a shlib function
2535     bpmv.clear();
2536     if (NULL == modA->findFunction("call22_5", bpmv) || !bpmv.size()) {
2537          fprintf(stderr, "**Failed test #22 (replace function)\n");
2538          fprintf(stderr, "  Mutator couldn't find functions in mutatee\n");
2539          exit(1);
2540     }
2541     BPatch_function *call22_5Afunc = bpmv[0];
2542
2543     bpmv.clear();
2544     if (NULL == modB->findFunction("call22_5", bpmv) || !bpmv.size()) {
2545          fprintf(stderr, "**Failed test #22 (replace function)\n");
2546          fprintf(stderr, "  Mutator couldn't find functions in mutatee\n");
2547          exit(1);
2548     }
2549     BPatch_function *call22_5Bfunc = bpmv[0];
2550
2551     if (! appThread->replaceFunction(*call22_5Afunc, *call22_5Bfunc)) {
2552          fprintf(stderr, "**Failed test #22 (replace function)\n");
2553          fprintf(stderr, "  Mutator couldn't replaceFunction (shlib -> shlib)\n");
2554     }
2555
2556     // Replace a shlib function with an a.out function
2557     bpmv.clear();
2558     if (NULL == modA->findFunction("call22_6", bpmv) || !bpmv.size()) {
2559          fprintf(stderr, "**Failed test #22 (replace function)\n");
2560          fprintf(stderr, "  Mutator couldn't find functions in mutatee\n");
2561          exit(1);
2562     }
2563     BPatch_function *call22_6func = bpmv[0];
2564
2565     bpfv.clear();
2566     char *fn4 = "call22_7";
2567     if (NULL == appImage->findFunction(fn4, bpfv) || !bpfv.size()
2568         || NULL == bpfv[0]){
2569       fprintf(stderr, "**Failed test #22 (replace function)\n");
2570       fprintf(stderr, "    Unable to find function %s\n", fn4);
2571       exit(1);
2572     }
2573     BPatch_function *call22_7func = bpfv[0];
2574
2575     if (! appThread->replaceFunction(*call22_6func, *call22_7func)) {
2576          fprintf(stderr, "**Failed test #22 (replace function)\n");
2577          fprintf(stderr, "  Mutator couldn't replaceFunction (shlib -> a.out)\n");
2578          exit(1);
2579     }
2580
2581 #endif
2582 }
2583
2584 //
2585 // Start Test Case #23 - local variables
2586 //
2587 void mutatorTest23(BPatch_thread *appThread, BPatch_image *appImage)
2588 {
2589 #if !defined(mips_sgi_irix6_4)
2590     if (!mutateeFortran) {
2591         //     First verify that we can find a local variable in call23_1
2592         BPatch_Vector<BPatch_function *> found_funcs;
2593         if ((NULL == appImage->findFunction("call23_1", found_funcs, 1)) 
2594             || !found_funcs.size()) {
2595             fprintf(stderr, "    Unable to find function %s\n",
2596                     "call23_1");
2597             exit(1);
2598         }
2599         
2600         if (1 < found_funcs.size()) {
2601             fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
2602                     __FILE__, __LINE__, found_funcs.size(), "call23_1");
2603         }
2604         
2605         BPatch_Vector<BPatch_point *> *point23_calls = found_funcs[0]->findPoint(BPatch_subroutine);    
2606         if (!point23_calls || (point23_calls->size() < 1)) {
2607             fprintf(stderr, "**Failed** test #23 (local variables)\n");
2608             fprintf(stderr, "  Unable to find point call23_1 - subroutine calls\n");
2609             exit(1);
2610         }
2611
2612         /* We only want the first one... */
2613     BPatch_Vector<BPatch_point *> point23_1;
2614     point23_1.push_back((*point23_calls)[0]);
2615
2616     BPatch_variableExpr *var1 = appImage->findVariable(*(point23_1[0]),
2617                                                        "localVariable23_1");
2618     BPatch_variableExpr *var2 = appImage->findVariable(*(point23_1[0]),
2619                                                        "shadowVariable23_1");
2620     BPatch_variableExpr *var3 = appImage->findVariable("shadowVariable23_2");
2621     BPatch_variableExpr *var4 = appImage->findVariable("globalVariable23_1");
2622     
2623     if (!var1 || !var2 || !var3 || !var4) {
2624         fprintf(stderr, "**Failed** test #23 (local variables)\n");
2625         if (!var1)
2626             fprintf(stderr, "  can't find local variable localVariable23_1\n");
2627         if (!var2)
2628             fprintf(stderr, "  can't find local variable shadowVariable23_1\n");
2629         if (!var3)
2630             fprintf(stderr,"  can't find global variable shadowVariable23_2\n");
2631         return;
2632     }
2633     
2634     BPatch_arithExpr expr23_1(BPatch_assign, *var1, BPatch_constExpr(2300001));
2635     BPatch_arithExpr expr23_2(BPatch_assign, *var2, BPatch_constExpr(2300012));
2636     BPatch_arithExpr expr23_3(BPatch_assign, *var3, BPatch_constExpr(2300023));
2637     BPatch_arithExpr expr23_4(BPatch_assign, *var4, *var1);
2638     
2639     BPatch_Vector<BPatch_snippet *> exprs;
2640     
2641     exprs.push_back(&expr23_1);
2642     exprs.push_back(&expr23_2);
2643     exprs.push_back(&expr23_3);
2644     exprs.push_back(&expr23_4);
2645     
2646     BPatch_sequence allParts(exprs);
2647     
2648     // this should not be needed???  JAW
2649     //BPatch_Vector<BPatch_point *> *points = found_funcs[0]->findPoint(BPatch_subroutine);
2650     
2651     appThread->insertSnippet(allParts, point23_1);
2652
2653     }
2654 #endif
2655 }
2656
2657 //
2658 // Start Test Case #24 - array variables
2659 //
2660 void mutatorTest24(BPatch_thread *appThread, BPatch_image *appImage)
2661 {
2662 #if !defined(mips_sgi_irix6_4)
2663     if (!mutateeFortran) {
2664         //     First verify that we can find function call24_1
2665       BPatch_Vector<BPatch_function *> bpfv;
2666       char *fn = "call24_1";
2667       if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() ||
2668               NULL == bpfv[0]){
2669             fprintf(stderr, "    Unable to find function %s\n", fn);
2670             exit(1);
2671       }
2672       
2673       BPatch_function *call24_1_func = bpfv[0];
2674       
2675       BPatch_Vector<BPatch_point *> *temp = call24_1_func->findPoint(BPatch_subroutine);
2676       
2677       //     Then verify that we can find a local variable in call24_1
2678       if (!temp) {
2679             fprintf(stderr, "**Failed** test #24 (array variables)\n");
2680             fprintf(stderr, "  can't find function call24_1\n");
2681             return;
2682         } else {
2683             dprintf("Found %d callsites in function call24_1\n", temp->size());
2684         }
2685
2686         BPatch_Vector<BPatch_point *> *point24_1 = new BPatch_Vector<BPatch_point *>;
2687         point24_1->push_back((*temp)[0]);
2688
2689         BPatch_Vector<BPatch_point *> *point24_2 = call24_1_func->findPoint(BPatch_exit);
2690         BPatch_Vector<BPatch_point *> *point24_3 = call24_1_func->findPoint(BPatch_entry);
2691  
2692         assert(point24_1 && point24_2 && point24_3);
2693
2694         BPatch_variableExpr *lvar;
2695         BPatch_variableExpr *gvar[10];
2696
2697         for (int i=1; i <= 9; i++) {
2698             char name[80];
2699
2700             sprintf(name, "globalVariable24_%d", i);
2701             gvar[i] = appImage->findVariable(name);
2702             if (!gvar[i]) {
2703                 fprintf(stderr, "**Failed** test #24 (array variables)\n");
2704                 fprintf(stderr, "  can't find variable globalVariable24_%d\n", i);
2705                 return;
2706             }
2707         }
2708
2709         lvar = appImage->findVariable(*(*point24_1)[0], "localVariable24_1");
2710         if (!lvar) {
2711             fprintf(stderr, "**Failed** test #24 (array variables)\n");
2712             fprintf(stderr, "  can't find variable localVariable24_1\n");
2713             return;
2714         }
2715
2716         //     globalVariable24_1[1] = 2400001
2717         BPatch_arithExpr assignment1(BPatch_assign,
2718             BPatch_arithExpr(BPatch_ref, *gvar[1], BPatch_constExpr(1)),
2719             BPatch_constExpr(2400001));
2720         if (!appThread->insertSnippet(assignment1, *point24_1))
2721            abort();
2722
2723         //     globalVariable24_1[globalVariable24_2] = 2400002
2724         BPatch_arithExpr assignment2(BPatch_assign,
2725             BPatch_arithExpr(BPatch_ref, *gvar[1], *gvar[2]),
2726         BPatch_constExpr(2400002));
2727         if (!appThread->insertSnippet(assignment2, *point24_1))
2728           abort();
2729
2730         //     globalVariable24_3 = globalVariable24_1[79]
2731         BPatch_arithExpr assignment3(BPatch_assign, *gvar[3],
2732             BPatch_arithExpr(BPatch_ref, *gvar[1], BPatch_constExpr(79)));
2733         if (!appThread->insertSnippet(assignment3, *point24_1))
2734           abort();
2735
2736         //     globalVariable24_5 = globalVariable24_1[globalVariable24_4]
2737         BPatch_arithExpr assignment4(BPatch_assign, *gvar[5],
2738             BPatch_arithExpr(BPatch_ref, *gvar[1], *gvar[4]));
2739         appThread->insertSnippet(assignment4, *point24_1);
2740
2741         // now the local variables
2742         //     localVariable24_1[1] = 2400005
2743         BPatch_arithExpr *bpae = new BPatch_arithExpr(BPatch_ref, 
2744                                                       *lvar, 
2745                                                       BPatch_constExpr(1));
2746         BPatch_constExpr *bpce = new BPatch_constExpr(2400005);
2747         BPatch_arithExpr assignment5(BPatch_assign, *bpae, *bpce);
2748         if (!appThread->insertSnippet(assignment5, *point24_1))
2749           abort();
2750
2751         //     localVariable24_1[globalVariable24_2] = 2400006
2752         BPatch_arithExpr assignment6(BPatch_assign,
2753             BPatch_arithExpr(BPatch_ref, *lvar, *gvar[2]),
2754             BPatch_constExpr(2400006));
2755         if (!appThread->insertSnippet(assignment6, *point24_1))
2756           abort();
2757
2758         //     globalVariable24_6 = localVariable24_1[79]
2759         BPatch_arithExpr *ae = 
2760            new BPatch_arithExpr(BPatch_ref, *lvar, BPatch_constExpr(79));
2761         BPatch_arithExpr assignment7(BPatch_assign, *gvar[6],*ae);
2762         if (!appThread->insertSnippet(assignment7, *point24_1))
2763           abort();
2764
2765         //     globalVariable24_7 = localVariable24_1[globalVariable24_4]
2766         BPatch_arithExpr assignment8(BPatch_assign, *gvar[7],
2767             BPatch_arithExpr(BPatch_ref, *lvar, *gvar[4]));
2768         if (!appThread->insertSnippet(assignment8, *point24_1))
2769           abort();
2770
2771         // now test multi-dimensional arrays
2772         //         globalVariable24_8[2][3] = 2400011
2773         BPatch_arithExpr assignment9(BPatch_assign, 
2774             BPatch_arithExpr(BPatch_ref, BPatch_arithExpr(BPatch_ref, *gvar[8],
2775             BPatch_constExpr(2)), BPatch_constExpr(3)), BPatch_constExpr(2400011));
2776         if (!appThread->insertSnippet(assignment9, *point24_1))
2777           abort();
2778
2779         // globalVariable24_9 = globalVariable24_8[7][9]
2780         BPatch_arithExpr assignment10(BPatch_assign, *gvar[9],
2781             BPatch_arithExpr(BPatch_ref, BPatch_arithExpr(BPatch_ref, *gvar[8],
2782             BPatch_constExpr(7)), BPatch_constExpr(9)));
2783         if (!appThread->insertSnippet(assignment10, *point24_1))
2784           abort();
2785     }
2786 #endif
2787 }
2788
2789 //
2790 // Start Test Case #25 - unary operators
2791 //
2792 void mutatorTest25(BPatch_thread *appThread, BPatch_image *appImage)
2793 {
2794         // Used as hack for Fortran to allow assignment of a pointer to an int
2795         bpatch->setTypeChecking (false);
2796 #if !defined(mips_sgi_irix6_4)
2797     //     First verify that we can find a local variable in call25_1
2798   BPatch_Vector<BPatch_function *> found_funcs;
2799     if ((NULL == appImage->findFunction("call25_1", found_funcs)) || !found_funcs.size()) {
2800        fprintf(stderr, "    Unable to find function %s\n",
2801               "call25_1");
2802       exit(1);
2803     }
2804
2805     if (1 < found_funcs.size()) {
2806       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
2807               __FILE__, __LINE__, found_funcs.size(), "call25_1");
2808     }
2809
2810     BPatch_Vector<BPatch_point *> *point25_1 = found_funcs[0]->findPoint(BPatch_entry);
2811
2812     assert(point25_1);
2813 //    assert(point25_1 && (point25_1->size() == 1));
2814
2815     BPatch_variableExpr *gvar[8];
2816
2817     for (int i=1; i <= 7; i++) {
2818         char name[80];
2819
2820         sprintf (name, "globalVariable25_%d", i);
2821         gvar [i] = findVariable (appImage, name, point25_1);
2822
2823         if (!gvar[i]) {
2824             fprintf(stderr, "**Failed** test #25 (unary operaors)\n");
2825             fprintf(stderr, "  can't find variable globalVariable25_%d\n", i);
2826             exit(-1);
2827         }
2828     }
2829
2830     //     globalVariable25_2 = &globalVariable25_1
2831 #if !defined(sparc_sun_solaris2_4) \
2832  && !defined(rs6000_ibm_aix4_1) \
2833  && !defined(alpha_dec_osf4_0) \
2834  && !defined(i386_unknown_linux2_0) \
2835  && !defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
2836  && !defined(ia64_unknown_linux2_4) \
2837  && !defined(i386_unknown_solaris2_5) \
2838  && !defined(i386_unknown_nt4_0) \
2839  && !defined(ppc64_linux)
2840
2841     // without type info need to inform
2842     BPatch_type *type = appImage->findType("void *");
2843     assert(type);
2844     gvar[2]->setType(type);
2845 #endif
2846
2847     BPatch_arithExpr assignment1(BPatch_assign, *gvar[2],
2848         BPatch_arithExpr(BPatch_addr, *gvar[1]));
2849
2850     appThread->insertSnippet(assignment1, *point25_1);
2851
2852     //     globalVariable25_3 = *globalVariable25_2
2853     //          Need to make sure this happens after the first one
2854     BPatch_arithExpr assignment2(BPatch_assign, *gvar[3],
2855         BPatch_arithExpr(BPatch_deref, *gvar[2]));
2856     appThread->insertSnippet(assignment2, *point25_1,  BPatch_callBefore,
2857             BPatch_lastSnippet);
2858
2859     //     globalVariable25_5 = -globalVariable25_4
2860     BPatch_arithExpr assignment3(BPatch_assign, *gvar[5],
2861         BPatch_arithExpr(BPatch_negate, *gvar[4]));
2862     appThread->insertSnippet(assignment3, *point25_1);
2863
2864     //     globalVariable25_7 = -globalVariable25_6
2865     BPatch_arithExpr assignment4(BPatch_assign, *gvar[7],
2866         BPatch_arithExpr(BPatch_negate, *gvar[6]));
2867     appThread->insertSnippet(assignment4, *point25_1);
2868
2869 #endif
2870         bpatch->setTypeChecking (true);
2871 }
2872
2873
2874 //
2875 // Start Test Case #26 - struct elements
2876 //
2877 void mutatorTest26(BPatch_thread *appThread, BPatch_image *appImage)
2878 {
2879 #if !defined(mips_sgi_irix6_4)
2880
2881     if (!mutateeFortran) {
2882         //     First verify that we can find a local variable in call26_1
2883         BPatch_Vector<BPatch_function *> found_funcs;
2884         if ((NULL == appImage->findFunction("call26_1", found_funcs, 1)) || !found_funcs.size()) {
2885            fprintf(stderr, "    Unable to find function %s\n",
2886                   "call26_1");
2887           exit(1);
2888         }
2889
2890         if (1 < found_funcs.size()) {
2891           fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
2892                   __FILE__, __LINE__, found_funcs.size(), "call26_1");
2893         }
2894
2895         BPatch_Vector<BPatch_point *> *point26_1 = found_funcs[0]->findPoint(BPatch_subroutine);
2896         BPatch_Vector<BPatch_point *> *point26_2 = found_funcs[0]->findPoint(BPatch_subroutine);
2897
2898         assert(point26_1 && (point26_1->size() == 1));
2899         assert(point26_2);
2900
2901         BPatch_variableExpr *lvar;
2902         BPatch_variableExpr *gvar[14];
2903
2904         int i;
2905         for (i=1; i <= 13; i++) {
2906             char name[80];
2907
2908             sprintf (name, "globalVariable26_%d", i);
2909             gvar [i] = findVariable(appImage, name, point26_2);
2910
2911             if (!gvar[i]) {
2912                 fprintf(stderr, "**Failed** test #26 (struct elements)\n");
2913                 fprintf(stderr, "  can't find variable globalVariable26_%d\n", i);
2914                 exit(-1);
2915             }
2916         }
2917
2918         // start of code for globalVariable26_1
2919         BPatch_Vector<BPatch_variableExpr *> *fields = gvar[1]->getComponents();
2920         if (!fields) {
2921             fprintf(stderr, "**Failed** test #26 (struct elements)\n");
2922             fprintf(stderr, "  struct lacked correct number of elements\n");
2923             exit(-1);
2924         }
2925
2926         for (i=0; i < 4; i++) {
2927             char fieldName[80];
2928             sprintf(fieldName, "field%d", i+1);
2929             if (!(*fields)[i]->getName())
2930                 printf("NULL NAME!\n");
2931             if (strcmp(fieldName, (*fields)[i]->getName())) {
2932                 printf("field %d of the struct is %s, not %s\n",
2933                     i+1, fieldName, (*fields)[i]->getName());
2934                 return;
2935             }
2936         }
2937
2938             //     globalVariable26_2 = globalVariable26_1.field1
2939         BPatch_arithExpr assignment1(BPatch_assign, *gvar[2], *((*fields)[0]));
2940             appThread->insertSnippet(assignment1, *point26_2);
2941
2942         //         globalVariable26_3 = globalVariable26_1.field2
2943             BPatch_arithExpr assignment2(BPatch_assign, *gvar[3], *((*fields)[1]));
2944         appThread->insertSnippet(assignment2, *point26_2);
2945
2946             //     globalVariable26_4 = globalVariable26_1.field3[0]
2947         BPatch_arithExpr assignment3(BPatch_assign, *gvar[4],
2948                 BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(0)));
2949         appThread->insertSnippet(assignment3, *point26_2);
2950
2951             //     globalVariable26_5 = globalVariable26_1.field3[5]
2952         BPatch_arithExpr assignment4(BPatch_assign, *gvar[5],
2953                 BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(5)));
2954         appThread->insertSnippet(assignment4, *point26_2);
2955
2956             BPatch_Vector<BPatch_variableExpr *> *subfields =
2957                 (*fields)[3]->getComponents();
2958             assert(subfields != NULL);
2959
2960         //         globalVariable26_6 = globalVariable26_1.field4.field1
2961             BPatch_arithExpr assignment5(BPatch_assign, *gvar[6], *((*subfields)[0]));
2962         appThread->insertSnippet(assignment5, *point26_2);
2963
2964             //     globalVariable26_7 = globalVariable26_1.field4.field2
2965         BPatch_arithExpr assignment6(BPatch_assign, *gvar[7], *((*subfields)[1]));
2966             appThread->insertSnippet(assignment6, *point26_2);
2967
2968         // start of code for localVariable26_1
2969         expectError = 100;
2970         lvar = appImage->findVariable(*(*point26_1) [0], "localVariable26_1");
2971         if (!lvar) {
2972                 fprintf(stderr, "**Failed** test #26 (struct elements)\n");
2973                 fprintf(stderr, "  could not find localVariable26_1\n");
2974             return;
2975         }
2976         
2977         expectError = DYNINST_NO_ERROR;
2978
2979         fields = lvar->getComponents();
2980         if (!fields || (fields->size() < 4)) {
2981             fprintf(stderr, "**Failed** test #26 (struct elements)\n");
2982             fprintf(stderr, "  struct lacked correct number of elements\n");
2983             exit(-1);
2984         }
2985
2986         for (i=0; i < 4; i++) {
2987             char fieldName[80];
2988             sprintf(fieldName, "field%d", i+1);
2989             if (strcmp(fieldName, (*fields)[i]->getName())) {
2990                 printf("field %d of the local struct is %s, not %s\n",
2991                       i+1, fieldName, (*fields)[i]->getName());
2992                 return;
2993             }
2994         }
2995
2996         //         globalVariable26_8 = localVariable26_1.field1
2997         BPatch_arithExpr assignment7(BPatch_assign, *gvar[8], *((*fields)[0]));
2998             appThread->insertSnippet(assignment7, *point26_1);
2999
3000         //         globalVariable26_9 = localVariable26_1.field2
3001         BPatch_arithExpr assignment8(BPatch_assign, *gvar[9], *((*fields)[1]));
3002         appThread->insertSnippet(assignment8, *point26_1);
3003
3004         //         globalVariable26_10 = localVariable26_1.field3[0]
3005         BPatch_arithExpr assignment9(BPatch_assign, *gvar[10],
3006             BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(0)));
3007         appThread->insertSnippet(assignment9, *point26_1);
3008
3009         //         globalVariable26_11 = localVariable26_1.field3[5]
3010         BPatch_arithExpr assignment10(BPatch_assign, *gvar[11],
3011             BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(5)));
3012         appThread->insertSnippet(assignment10, *point26_1);
3013
3014         subfields = (*fields)[3]->getComponents();
3015         assert(subfields != NULL);
3016
3017         //         globalVariable26_12 = localVariable26_1.field4.field1
3018         BPatch_arithExpr assignment11(BPatch_assign, *gvar[12], *((*subfields)[0]));
3019             appThread->insertSnippet(assignment11, *point26_1);
3020
3021         //         globalVariable26_13 = localVariable26_1.field4.field2
3022         BPatch_arithExpr assignment12(BPatch_assign, *gvar[13], *((*subfields)[1]));
3023             appThread->insertSnippet(assignment12, *point26_1);
3024     }
3025 #endif
3026 }
3027
3028 //
3029 // Start Test Case #27 - type compatibility
3030 //
3031 void mutatorTest27(BPatch_thread *, BPatch_image *appImage)
3032 {
3033 #if !defined(mips_sgi_irix6_4)
3034
3035     if (mutateeFortran) {
3036         return;
3037     }
3038
3039     BPatch_type *type27_1 = appImage->findType("type27_1");
3040     BPatch_type *type27_2 = appImage->findType("type27_2");
3041     BPatch_type *type27_3 = appImage->findType("type27_3");
3042     BPatch_type *type27_4 = appImage->findType("type27_4");
3043
3044     if (!type27_1 || !type27_2 || !type27_3 || !type27_4) {
3045         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3046         fprintf(stderr, "    Unable to locate one of type27_{1,2,3,4}\n");
3047         return;
3048     }
3049
3050     if (!type27_1->isCompatible(type27_2)) {
3051         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3052         fprintf(stderr,"    type27_1 reported as incompatibile with type27_2\n");
3053         return;
3054     }
3055
3056     if (!type27_2->isCompatible(type27_1)) {
3057         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3058         fprintf(stderr,"    type27_2 reported as incompatibile with type27_1\n");
3059         return;
3060     }
3061
3062     if (!type27_3->isCompatible(type27_3)) {
3063         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3064         fprintf(stderr,"    type27_3 reported as incompatibile with type27_4\n");
3065         return;
3066     }
3067
3068     if (!type27_4->isCompatible(type27_3)) {
3069         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3070         fprintf(stderr,"    type27_4 reported as incompatibile with type27_3\n");
3071         return;
3072     }
3073
3074     expectError = 112; // We're expecting type conflicts here
3075     if (type27_1->isCompatible(type27_3)) {
3076         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3077         fprintf(stderr,"    type27_1 reported as compatibile with type27_3\n");
3078         return;
3079     }
3080
3081     if (type27_4->isCompatible(type27_2)) {
3082         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3083         fprintf(stderr,"    type27_4 reported as compatibile with type27_2\n");
3084         return;
3085     }
3086     expectError = DYNINST_NO_ERROR;
3087
3088   BPatch_Vector<BPatch_function *> found_funcs;
3089     if ((NULL == appImage->findFunction("func27_1", found_funcs)) || !found_funcs.size()) {
3090       fprintf(stderr, "    Unable to find function %s\n",
3091               "func27_1");
3092       exit(1);
3093     }
3094
3095     if (1 < found_funcs.size()) {
3096       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
3097               __FILE__, __LINE__, found_funcs.size(), "func27_1");
3098     }
3099
3100     BPatch_Vector<BPatch_point *> *point27_1 = found_funcs[0]->findPoint(BPatch_entry);
3101
3102     assert (point27_1);
3103
3104     BPatch_variableExpr *expr27_5, *expr27_6, *expr27_7, *expr27_8;
3105
3106     expr27_5 = findVariable(appImage, "globalVariable27_5", point27_1);
3107     expr27_6 = findVariable(appImage, "globalVariable27_6", point27_1);
3108     expr27_7 = findVariable(appImage, "globalVariable27_7", point27_1);
3109     expr27_8 = findVariable(appImage, "globalVariable27_8", point27_1);
3110
3111     assert(expr27_5 && expr27_6 && expr27_7 && expr27_8);
3112
3113     BPatch_type *type27_5 = const_cast<BPatch_type *> (expr27_5->getType());
3114     BPatch_type *type27_6 = const_cast<BPatch_type *> (expr27_6->getType());
3115     BPatch_type *type27_7 = const_cast<BPatch_type *> (expr27_7->getType());
3116     BPatch_type *type27_8 = const_cast<BPatch_type *> (expr27_8->getType());
3117
3118     assert(type27_5 && type27_6 && type27_7 && type27_8);
3119
3120     if (!type27_5->isCompatible(type27_6)) {
3121         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3122         fprintf(stderr,"    type27_5 reported as incompatibile with type27_6\n");
3123         return;
3124     }
3125
3126     // difderent number of elements
3127     expectError = 112; // We're expecting type conflicts here
3128     if (type27_5->isCompatible(type27_7)) {
3129         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3130         fprintf(stderr,"    type27_5 reported as compatibile with type27_7\n");
3131         return;
3132     }
3133
3134     // same # of elements, different type
3135     if (type27_5->isCompatible(type27_8)) {
3136         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3137         fprintf(stderr,"    type27_5 reported as compatibile with type27_8\n");
3138         return;
3139     }
3140
3141     // all ok, set the global variable, depends on test 18 working
3142     BPatch_variableExpr *expr27_1 = findVariable(appImage, "globalVariable27_1", point27_1);
3143
3144     if (expr27_1 == NULL) {
3145         fprintf(stderr, "**Failed** test #27 (type compatibility)\n");
3146         fprintf(stderr, "    Unable to locate globalVariable27_1\n");
3147         return;
3148     }
3149     expectError = DYNINST_NO_ERROR;
3150
3151     int n = 1;
3152     expr27_1->writeValue(&n, true); //ccw 31 jul 2002
3153 #endif
3154 }
3155
3156 //
3157 // Start Test Case #28 - user defined fields
3158 //
3159 void mutatorTest28(BPatch_thread *appThread, BPatch_image *appImage)
3160 {
3161     int i;
3162
3163     //     Create the types
3164     BPatch_type *intType = appImage->findType("int");
3165     assert(intType);
3166
3167     BPatch_Vector<char *> names;
3168     BPatch_Vector<BPatch_type *> types;
3169
3170     if (mutateeFortran) {
3171         return;
3172     }
3173
3174     names.push_back(const_cast<char*>("field1"));
3175     names.push_back(const_cast<char*>("field2"));
3176     types.push_back(intType);
3177     types.push_back(intType);
3178
3179     //  struct28_1 { int field1, int field 2; }
3180     BPatch_type *struct28_1 = bpatch->createStruct("struct28_1", names, types);
3181     BPatch_type *union28_1 = bpatch->createUnion("testUnion27_1", names, types);
3182     assert(union28_1);
3183
3184     names.push_back(const_cast<char*>("field3"));
3185     names.push_back(const_cast<char*>("field4"));
3186
3187     BPatch_type *intArray = bpatch->createArray("intArray", intType, 0, 9);
3188
3189     types.push_back(intArray);
3190     types.push_back(struct28_1);
3191
3192     // struct28_2 { int field1, int field 2, int field3[10],struct26_1 field4 } 
3193     BPatch_type *struct28_2 = bpatch->createStruct("struct28_2", names, types);
3194     BPatch_type *type28_2 = bpatch->createTypedef("type28_2", struct28_2);
3195
3196     // now create variables of these types.
3197     BPatch_variableExpr *globalVariable28_1 = 
3198         appImage->findVariable("globalVariable28_1");
3199     assert(globalVariable28_1);
3200     globalVariable28_1->setType(type28_2);
3201
3202     BPatch_variableExpr *globalVariable28_8 = 
3203         appImage->findVariable("globalVariable28_8");
3204     assert(globalVariable28_8);
3205     globalVariable28_8->setType(union28_1);
3206
3207     //     Next verify that we can find a local variable in call28
3208     BPatch_Vector<BPatch_function *> found_funcs;
3209     if ((NULL == appImage->findFunction("call28_1", found_funcs)) || !found_funcs.size()) {
3210        fprintf(stderr, "    Unable to find function %s\n",
3211               "call28_1");
3212       exit(1);
3213     }
3214
3215     if (1 < found_funcs.size()) {
3216       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
3217               __FILE__, __LINE__, found_funcs.size(), "call28_1");
3218     }
3219
3220     BPatch_Vector<BPatch_point *> *point28 = found_funcs[0]->findPoint(BPatch_entry);
3221
3222     assert(point28 && (point28->size() == 1));
3223
3224     BPatch_variableExpr *gvar[8];
3225
3226     for (i=1; i <= 7; i++) {
3227         char name[80];
3228
3229         sprintf(name, "globalVariable28_%d", i);
3230         gvar[i] = appImage->findVariable(name);
3231         if (!gvar[i]) {
3232             fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3233             fprintf(stderr, "  can't find variable globalVariable28_%d\n", i);
3234             exit(-1);
3235         }
3236     }
3237
3238     // start of code for globalVariable28
3239     BPatch_Vector<BPatch_variableExpr *> *fields = gvar[1]->getComponents();
3240     assert(fields && (fields->size() == 4));
3241
3242     for (i=0; i < 4; i++) {
3243          char fieldName[80];
3244          sprintf(fieldName, "field%d", i+1);
3245          if (strcmp(fieldName, (*fields)[i]->getName())) {
3246               printf("field %d of the struct is %s, not %s\n",
3247                   i+1, fieldName, (*fields)[i]->getName());
3248               return;
3249          }
3250     }
3251
3252     //     globalVariable28 = globalVariable28.field1
3253     BPatch_arithExpr assignment1(BPatch_assign, *gvar[2], *((*fields)[0]));
3254     appThread->insertSnippet(assignment1, *point28);
3255
3256     //     globalVariable28 = globalVariable28.field2
3257     BPatch_arithExpr assignment2(BPatch_assign, *gvar[3], *((*fields)[1]));
3258     appThread->insertSnippet(assignment2, *point28);
3259
3260     //     globalVariable28 = globalVariable28.field3[0]
3261     BPatch_arithExpr assignment3(BPatch_assign, *gvar[4], 
3262         BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(0)));
3263     appThread->insertSnippet(assignment3, *point28);
3264
3265     //     globalVariable28 = globalVariable28.field3[5]
3266     BPatch_arithExpr assignment4(BPatch_assign, *gvar[5], 
3267         BPatch_arithExpr(BPatch_ref, *((*fields)[2]), BPatch_constExpr(5)));
3268     appThread->insertSnippet(assignment4, *point28);
3269
3270     BPatch_Vector<BPatch_variableExpr *> *subfields = 
3271         (*fields)[3]->getComponents();
3272     assert(subfields != NULL);
3273
3274     //     globalVariable28 = globalVariable28.field4.field1
3275     BPatch_arithExpr assignment5(BPatch_assign, *gvar[6], *((*subfields)[0]));
3276     appThread->insertSnippet(assignment5, *point28);
3277
3278     //     globalVariable28 = globalVariable28.field4.field2
3279     BPatch_arithExpr assignment6(BPatch_assign, *gvar[7], *((*subfields)[1]));
3280     appThread->insertSnippet(assignment6, *point28);
3281
3282     // 
3283     BPatch_Vector<BPatch_variableExpr *> *unionfields = globalVariable28_8->getComponents();
3284
3285     int n=1;
3286     int val1, val2, val3; 
3287
3288     ((*unionfields)[0])->writeValue(&n,true);
3289     ((*unionfields)[0])->readValue(&val1);
3290     if (val1 != 1) {
3291         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3292         fprintf(stderr, "  union field1 has wrong value after first set\n");
3293         exit(-1);
3294     }
3295
3296     n=2;
3297     ((*unionfields)[1])->writeValue(&n,true);
3298     ((*unionfields)[1])->readValue(&val2);
3299     if (val2 != 2) {
3300         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3301         fprintf(stderr, "  union field2 has wrong value after second set\n");
3302         exit(-1);
3303     }
3304
3305     ((*unionfields)[1])->readValue(&val3);
3306     if (val3 != 2) {
3307         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3308         fprintf(stderr, "  union field1 has wrong value after second set\n");
3309         exit(-1);
3310     }
3311
3312     // create a scalar
3313     BPatch_type *newScalar1 = bpatch->createScalar("scalar1", 8);
3314     assert(newScalar1);
3315     int scalarSize = newScalar1->getSize();
3316     if (scalarSize != 8) {
3317         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3318         fprintf(stderr, "  created scalar is %d bytes, expected %d\n", scalarSize, 8);
3319         exit(-1);
3320     }
3321
3322     // create an enum
3323     BPatch_Vector<char *> enumItems;
3324     BPatch_Vector<int> enumVals;
3325
3326     enumItems.push_back(const_cast<char*>("item1"));
3327     enumItems.push_back(const_cast<char*>("item2"));
3328     enumItems.push_back(const_cast<char*>("item3"));
3329
3330     enumVals.push_back(42);
3331     enumVals.push_back(43);
3332     enumVals.push_back(44);
3333
3334     BPatch_type *newEnum1 = bpatch->createEnum("enum1", enumItems);
3335     BPatch_type *newEnum2 = bpatch->createEnum("enum2", enumItems, enumVals);
3336
3337     if (!newEnum1 || !newEnum2) {
3338         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3339         fprintf(stderr, "  failed to create enums as expected\n");
3340         exit(-1);
3341     }
3342
3343     if (!newEnum1->isCompatible(newEnum1)) {
3344         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3345         fprintf(stderr, "  identical enums reported incompatible\n");
3346         exit(-1);
3347     }
3348
3349     if (newEnum1->isCompatible(newEnum2)) {
3350         fprintf(stderr, "**Failed** test #28 (user defined fields)\n");
3351         fprintf(stderr, "  different enums declared compatible\n");
3352         exit(-1);
3353         
3354     }
3355 }
3356
3357 bool printSrcObj(BPatch_sourceObj *p, int level)
3358 {
3359     unsigned int i;
3360     bool ret = true;
3361
3362     BPatch_Vector<BPatch_sourceObj *> curr;
3363
3364     if (!p) return(true);
3365
3366     switch (p->getSrcType()) {
3367         case BPatch_sourceProgram:
3368             if (level != 0) ret = false;
3369             break;
3370
3371         case BPatch_sourceModule: 
3372             if (level != 1) ret = false;
3373             break;
3374
3375         case BPatch_sourceFunction: 
3376             if (level != 2) ret = false;
3377             break;
3378
3379         default:
3380             printf("<unknown type>");
3381     }
3382
3383     if (!p->getSourceObj(curr)) {
3384         // eveything down to functions should have something
3385         return((level == 2) ? true : false);
3386     }
3387
3388     for (i=0; i < curr.size(); i++) {
3389         p = curr[i];
3390         ret = printSrcObj(p, level+1) && ret;
3391     }
3392
3393     return ret;
3394 }
3395
3396 //
3397 // Start Test Case #29 - getParent/Child
3398 //
3399 void mutatorTest29(BPatch_thread *, BPatch_image *appImage)
3400 {
3401     BPatch_sourceObj *p;
3402
3403     p = (BPatch_sourceObj *) appImage;
3404     passedTest[29] = printSrcObj(p, 0);
3405
3406     if (!passedTest[29]) {
3407         fprintf(stderr, "**Failed** test #29 (class BPatch_srcObj)\n");
3408         return;
3409     }
3410
3411   BPatch_Vector<BPatch_function *> found_funcs;
3412     if ((NULL == appImage->findFunction("func29_1", found_funcs)) || !found_funcs.size()) {
3413       fprintf(stderr, "    Unable to find function %s\n",
3414               "func29_1");
3415       exit(1);
3416     }
3417
3418     if (1 < found_funcs.size()) {
3419       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
3420               __FILE__, __LINE__, found_funcs.size(), "func29_1");
3421     }
3422
3423     BPatch_Vector<BPatch_point *> *point29_1 = found_funcs[0]->findPoint(BPatch_entry);
3424
3425     assert (point29_1);
3426
3427     BPatch_variableExpr *expr29_1 = findVariable(appImage, "globalVariable29_1", point29_1);
3428
3429     if (expr29_1 == NULL) {
3430         fprintf(stderr, "**Failed** test #29 (class BPatch_srcObj)\n");
3431         fprintf(stderr, "    Unable to locate globalVariable29_1\n");
3432         return;
3433     }
3434     expectError = DYNINST_NO_ERROR;
3435
3436     int n = 1;
3437     expr29_1->writeValue(&n,true); //ccw 31 jul 2002
3438 }
3439
3440 //
3441 // Start Test Case #30 - (line information)
3442 //
3443 void mutatorTest30(BPatch_thread *appThread, BPatch_image *appImage)
3444 {
3445
3446 #if defined(sparc_sun_solaris2_4) \
3447  || defined(i386_unknown_solaris2_5) \
3448  || defined(i386_unknown_linux2_0) \
3449  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */ \
3450  || defined(ia64_unknown_linux2_4) \
3451  || defined(i386_unknown_nt4_0) \
3452  || defined(rs6000_ibm_aix4_1) \
3453  || defined(alpha_dec_osf4_0)
3454
3455   unsigned long n;
3456   unsigned long baseAddr,lastAddr;
3457   unsigned int call30_1_line_no;
3458
3459         if (mutateeFortran) {
3460             return;
3461         } 
3462   BPatch_Vector<BPatch_function *> found_funcs;
3463     if ((NULL == appImage->findFunction("func30_1", found_funcs)) || !found_funcs.size()) {
3464       fprintf(stderr, "    Unable to find function %s\n",
3465               "func30_1");
3466       exit(1);
3467     }
3468
3469     if (1 < found_funcs.size()) {
3470       fprintf(stderr, "%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
3471               __FILE__, __LINE__, found_funcs.size(), "func30_1");
3472     }
3473
3474
3475     BPatch_Vector<BPatch_point *> *point30_1 = found_funcs[0]->findPoint(BPatch_entry);
3476         //instrument with the function that will set the line number
3477
3478         if (!point30_1 || (point30_1->size() < 1)) {
3479                 fprintf(stderr, "Unable to find point func30_1 - entry.\n");
3480                 exit(-1);
3481         }
3482
3483         BPatch_Vector<BPatch_function *> bpfv;
3484         char *fn = "call30_1";
3485         if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size()
3486             || NULL == bpfv[0]){
3487           fprintf(stderr, "    Unable to find function %s\n", fn);
3488           exit(1);
3489         }
3490         
3491         BPatch_function *call30_1func = bpfv[0];
3492
3493         BPatch_Vector<BPatch_snippet *> nullArgs;
3494         BPatch_funcCallExpr call30_1Expr(*call30_1func, nullArgs);
3495
3496         checkCost(call30_1Expr);
3497         appThread->insertSnippet(call30_1Expr, *point30_1);
3498
3499         //get the line number of the function call30_1
3500         BPatch_variableExpr *expr30_7 = 
3501                 appImage->findVariable("globalVariable30_7");
3502         if (expr30_7 == NULL) {
3503                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3504                 fprintf(stderr, "    Unable to locate globalVariable30_7\n");
3505                 exit(1);
3506         }
3507         expr30_7->readValue(&n);
3508         call30_1_line_no = (unsigned)(n+1);
3509
3510         //get the base addr and last addr of the function call30_1
3511         baseAddr = (unsigned long)(call30_1func->getBaseAddr());
3512         lastAddr = baseAddr + call30_1func->getSize();
3513
3514         //now write the base address and last address of the function
3515         BPatch_variableExpr *expr30_8 = 
3516                         appImage->findVariable("globalVariable30_8");
3517         if (expr30_8 == NULL) {
3518                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3519                 fprintf(stderr, "    Unable to locate globalVariable30_8\n");
3520         }
3521
3522         BPatch_variableExpr *expr30_9 = 
3523                         appImage->findVariable("globalVariable30_9");
3524         if (expr30_9 == NULL) {
3525                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3526                 fprintf(stderr, "    Unable to locate globalVariable30_9\n");
3527         }
3528
3529         expr30_8->writeValue(&baseAddr);
3530         expr30_9->writeValue(&lastAddr);
3531         
3532         
3533         //check getLineAddr for appImage
3534         BPatch_variableExpr *expr30_3 =
3535                         appImage->findVariable("globalVariable30_3");
3536         if (expr30_3 == NULL) {
3537                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3538                 fprintf(stderr, "    Unable to locate globalVariable30_3\n");
3539                 exit(1);
3540         }
3541         
3542     std::vector< std::pair< unsigned long, unsigned long > > ranges;
3543     if( appImage->getAddressRanges( "test1.mutatee.c", call30_1_line_no, ranges ) ) {
3544         n = ranges[0].first;
3545         expr30_3->writeValue( & n );
3546         }
3547         
3548         //check getLineAddr for module
3549         BPatch_variableExpr *expr30_4 =
3550                         appImage->findVariable("globalVariable30_4");
3551         if (expr30_4 == NULL) {
3552                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3553                 fprintf(stderr, "    Unable to locate globalVariable30_4\n");
3554                 exit(1);
3555         }
3556         BPatch_Vector<BPatch_module*>* appModules = appImage->getModules();
3557         for (unsigned int i=0;i<appModules->size();i++){
3558                 char mname[256];
3559                 (*appModules)[i]->getName(mname,255);mname[255] = '\0';
3560                 if (!strncmp(mname,"test1.mutatee.c",15)){
3561                         ranges.clear();
3562                         if ( (*appModules)[i]->getAddressRanges( NULL, call30_1_line_no, ranges ) ) {
3563                                 n = ranges[0].first;
3564                                 expr30_4->writeValue( & n );
3565                         }
3566                         else fprintf(stderr,  "%s[%d]: BPatch_module->getAddressRanges returned false for line %d!\n", __FILE__, __LINE__, call30_1_line_no); 
3567                         break;
3568                 }
3569         }
3570
3571         //check getLineAddr works for the function
3572         BPatch_variableExpr *expr30_5 =
3573                 appImage->findVariable("globalVariable30_5");
3574         if (expr30_5 == NULL) {
3575                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3576                 fprintf(stderr, "    Unable to locate globalVariable30_5\n");
3577                 exit(1);
3578         }
3579         //check whether getLineFile works for appThread
3580         BPatch_variableExpr *expr30_6 =
3581                 appImage->findVariable("globalVariable30_6");
3582         if (expr30_6 == NULL) {
3583                 fprintf(stderr, "**Failed** test #30 (line information)\n");
3584                 fprintf(stderr, "    Unable to locate globalVariable30_6\n");
3585                 exit(1);