Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test_mem_1.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: test_mem_1.C,v 1.1 2008/10/30 19:21:51 legendre Exp $
33 /*
34  * #Name: test6_1
35  * #Desc: Load Instrumentation
36  * #Dep: 
37  * #Arch: !(sparc_sun_solaris2_4_test,,rs6000_ibm_aix4_1_test,i386_unknown_linux2_0_test,x86_64_unknown_linux2_4_test,i386_unknown_nt4_0_test,ia64_unknown_linux2_4_test)
38  * #Notes:
39  */
40
41 #include "BPatch.h"
42 #include "BPatch_Vector.h"
43 #include "BPatch_thread.h"
44 #include "BPatch_snippet.h"
45
46 #include "test_lib.h"
47 #include "test6.h"
48
49 #include "dyninst_comp.h"
50 class test_mem_1_Mutator : public DyninstMutator {
51 public:
52   virtual test_results_t executeTest();
53 };
54 extern "C" DLLEXPORT TestMutator *test_mem_1_factory() {
55   return new test_mem_1_Mutator();
56 }
57
58 #ifdef arch_sparc_test
59 static const unsigned int nloads = 15;
60 static BPatch_memoryAccess* loadList[nloads];
61 static void init_test_data()
62 {
63   int k=-1;
64
65   loadList[++k] = MK_LD(0,17,0,4);
66   loadList[++k] = MK_LD(3,1,-1,1);
67   loadList[++k] = MK_LD(2,2,-1,2);
68   loadList[++k] = MK_LD(0,17,0,8);
69   loadList[++k] = MK_LD(0,17,0,4);
70
71   loadList[++k] = MK_LS(3,17,-1,1); // ldstub
72   loadList[++k] = MK_LD(3,17,-1,1);
73
74   loadList[++k] = MK_LS(0,17,-1,4); // cas
75   loadList[++k] = MK_LS(0,17,-1,8); // casx
76   loadList[++k] = MK_LS(0,17,0,4);  // swap
77
78   loadList[++k] = MK_LD(0,17,0,4);
79   loadList[++k] = MK_LD(0,17,0,4);
80   loadList[++k] = MK_LD(0,17,0,8);
81   loadList[++k] = MK_LD(0,17,0,8);
82   loadList[++k] = MK_LD(0,17,0,16);
83 }
84 #endif
85
86 #ifdef arch_power_test
87 static const unsigned int nloads = 41;
88 static BPatch_memoryAccess* loadList[nloads];
89 static void init_test_data()
90 {
91   int k=-1;
92
93   loadList[++k] = MK_LD(0, 7, -1, 4); // from la, l sequence
94
95   loadList[++k] = MK_LD(17, 7, -1, 1);
96   loadList[++k] = MK_LD(3, 7, -1, 1);
97
98   loadList[++k] = MK_LD(0, 3, 8, 1);
99   loadList[++k] = MK_LD(0, 3, 9, 1);
100
101   loadList[++k] = MK_LD(0, 3, -1, 2); // l6
102   loadList[++k] = MK_LD(4, 3, -1, 2);
103   loadList[++k] = MK_LD(2, 3, -1, 2);
104   loadList[++k] = MK_LD(0, 3, -1, 2);
105
106   loadList[++k] = MK_LD(0, 7, 9, 2); // l10
107   loadList[++k] = MK_LD(0, 7, 8, 2);
108   loadList[++k] = MK_LD(0, 7, 9, 2);
109   loadList[++k] = MK_LD(0, 7, 8, 2);
110
111   loadList[++k] = MK_LD(0, 7, -1, 4); // l14
112   loadList[++k] = MK_LD(4, 7, -1, 4);
113   loadList[++k] = MK_LD(0, 3, 9, 4);
114   loadList[++k] = MK_LD(0, 3, 9, 4);
115
116   loadList[++k] = MK_LD(4, 3, -1, 4); // l18
117   loadList[++k] = MK_LD(0, 7, 0, 4);  // 0 is 0 for rb...
118   loadList[++k] = MK_LD(0, 7, 8, 4);
119
120   loadList[++k] = MK_LD(0, 7, -1, 8); // l21
121   loadList[++k] = MK_LD(0, 3, -1, 8);
122   loadList[++k] = MK_LD(0, 7, 9, 8);
123   loadList[++k] = MK_LD(0, 3, 9, 8);
124
125   loadList[++k] = MK_LD(0, 8, 3, 2);  // l25
126   loadList[++k] = MK_LD(0, 9, 3, 4);
127
128   loadList[++k] = MK_LD(-76, 1, -1, 76);  // l27
129   loadList[++k] = MK_LD(0, 4, -1, 24);
130   loadList[++k] = new BPatch_memoryAccess(NULL, 0,
131                                    true, false,
132                                    (long)0, 1, 9,
133                                    (long)0, POWER_XER2531, -1);
134
135   loadList[++k] = MK_LD(0, -1, 3, 4);  // l30, 0 is -1 in ra...
136   loadList[++k] = MK_LD(0, -1, 7, 8);  // l31, idem
137
138   loadList[++k] = MK_LD(0, 4, -1, 4); // from la, l sequence
139
140   loadList[++k] = MK_LD(0, 4, -1, 4);
141   loadList[++k] = MK_LD(0, 4, 6, 4);
142   loadList[++k] = MK_LD(0, 4, -1, 4);
143   loadList[++k] = MK_LD(0, 6, 4, 4);
144
145   loadList[++k] = MK_LD(0, 6, -1, 4); // from la, l sequence
146
147   loadList[++k] = MK_LD(0, 6, -1, 8);
148   loadList[++k] = MK_LD(0, 6, 9, 8);
149   loadList[++k] = MK_LD(8, 6, -1, 8);
150   loadList[++k] = MK_LD(0, 9, 7, 8);
151 }
152 #endif
153
154 #if defined(i386_unknown_linux2_0_test) \
155  || defined(i386_unknown_nt4_0_test)
156 static const unsigned int nloads = 67;
157 static BPatch_memoryAccess* loadList[nloads];
158
159 static void *divarwp, *dfvarsp, *dfvardp, *dfvartp, *dlargep;
160
161 static void get_vars_addrs(BPatch_image* bip) // from mutatee
162 {
163   BPatch_variableExpr* bpvep_diwarw = bip->findVariable("divarw");
164   BPatch_variableExpr* bpvep_diwars = bip->findVariable("dfvars");
165   BPatch_variableExpr* bpvep_diward = bip->findVariable("dfvard");
166   BPatch_variableExpr* bpvep_diwart = bip->findVariable("dfvart");
167   BPatch_variableExpr* bpvep_dlarge = bip->findVariable("dlarge");
168   
169   divarwp = bpvep_diwarw->getBaseAddr();
170   dfvarsp = bpvep_diwars->getBaseAddr();
171   dfvardp = bpvep_diward->getBaseAddr();
172   dfvartp = bpvep_diwart->getBaseAddr();
173   dlargep = bpvep_dlarge->getBaseAddr();
174 }
175
176 static void init_test_data()
177 {
178   int k=-1;
179
180   loadList[++k] = MK_LD(0,0,-1,4);
181   loadList[++k] = MK_LD(0,1,-1,4);
182   loadList[++k] = MK_LD(0,2,-1,4);
183   loadList[++k] = MK_LD(0,3,-1,4);
184   loadList[++k] = MK_LD((long)divarwp,-1,-1,4);
185   loadList[++k] = MK_LD(0,6,-1,4);
186   loadList[++k] = MK_LD(0,7,-1,4);
187
188   loadList[++k] = MK_LD(4,0,-1,4); // l8
189   loadList[++k] = MK_LD(8,1,-1,4);
190   loadList[++k] = MK_LD(4,2,-1,4);
191   loadList[++k] = MK_LD(8,3,-1,4);
192   loadList[++k] = MK_LD(4,5,-1,4);
193   loadList[++k] = MK_LD(8,6,-1,4);
194   loadList[++k] = MK_LD(4,7,-1,4);
195
196   loadList[++k] = MK_LD((long)divarwp-1,0,-1,4); // l15
197   loadList[++k] = MK_LD((long)divarwp+3,1,-1,4);
198   loadList[++k] = MK_LD((long)divarwp+7,2,-1,4);
199   loadList[++k] = MK_LD((long)divarwp+11,3,-1,4);
200   loadList[++k] = MK_LD((long)divarwp-1,5,-1,4);
201   loadList[++k] = MK_LD((long)divarwp+3,6,-1,4);
202   loadList[++k] = MK_LD((long)divarwp+7,7,-1,4);
203
204   loadList[++k] = MK_LD(0,3,6,4); // l22
205   loadList[++k] = MK_LD(0,4,-1,4);
206   loadList[++k] = MK_LDsc(0,3,1,1,4);
207   loadList[++k] = MK_LDsc((long)divarwp,-1,1,1,4);
208   loadList[++k] = MK_LD(4,3,1,4);
209   loadList[++k] = MK_LDsc((long)divarwp,2,2,3,4);
210   loadList[++k] = MK_LDsc(2,5,1,1,4); // l28
211   loadList[++k] = MK_LDsc(4,3,1,2,4);
212   loadList[++k] = MK_LDsc((long)divarwp,5,1,2,4);
213   
214   loadList[++k] = MK_LD(0,4,-1,4);// l31
215   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4);
216   loadList[++k] = MK_LD((long)divarwp+4,-1,-1,4);
217   loadList[++k] = MK_LD2(0,6,-1,1,0,7,-1,1);
218
219   loadList[++k] = MK_LS((long)divarwp,-1,-1,4); // l35
220   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4);
221   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,4);
222 //   loadList[++k] = MK_LD((long)divarwp+2,-1,-1,6); // l38
223   loadList[++k] = MK_LD((long)divarwp,-1,-1,1);
224   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4); // l40
225   loadList[++k] = MK_LD((long)divarwp,-1,-1,4);
226
227   loadList[++k] = MK_LD((long)divarwp,-1,-1,4);
228   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,8);
229
230   loadList[++k] = MK_LD((long)dfvarsp,-1,-1,16); // l44
231   loadList[++k] = MK_LD((long)dfvarsp,-1,-1,4);
232
233   loadList[++k] = MK_LD((long)dfvardp,-1,-1,16);
234   loadList[++k] = MK_LD((long)dfvardp,-1,-1,8);
235
236   loadList[++k] = MK_LD((long)dfvarsp,-1,-1,8); // l48
237   loadList[++k] = MK_LD((long)dfvarsp+8,-1,-1,8);
238   
239
240   //loadList[++k] = MK_SL2(0,7,-1,4,0,6,-1,4); // l50
241   loadList[++k] = MK_SL2vECX(0,7,-1,0,6,-1,2);
242   loadList[++k] = new BPatch_memoryAccess(NULL, 0,
243                                           true, false,
244                                           0, 7, -1, 0,
245                                           0, -1, IA32_NESCAS, 0, 
246                                           -1, false);
247   loadList[++k] = new BPatch_memoryAccess(NULL, 0,
248                                           true, false,
249                                           0, 6, -1, 0,
250                                           0, -1, IA32_ECMPS, 0,
251                                           true, false,
252                                           0, 7, -1, 0,
253                                           0, -1, IA32_ECMPS, 0);
254
255   loadList[++k] = MK_LD((long)dfvarsp,-1,-1,4);
256   loadList[++k] = MK_LD((long)dfvardp,-1,-1,8);
257   loadList[++k] = MK_LD((long)dfvartp,-1,-1,10);
258   loadList[++k] = MK_LD((long)divarwp,-1,-1,2);
259   loadList[++k] = MK_LD((long)divarwp+4,-1,-1,4);
260   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,8);
261
262   loadList[++k] = MK_LD((long)divarwp,-1,-1,2);
263   loadList[++k] = MK_LD((long)dlargep,-1,-1,28);
264
265   loadList[++k] = MK_LDsccnd((long)divarwp,-1,-1,0,4,7); // cmova
266   loadList[++k] = MK_LDsccnd((long)divarwp+4,-1,-1,0,4,4); // cmove
267   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,4);
268
269   loadList[++k] = MK_LD(0,4,-1,4); // final pops
270   loadList[++k] = MK_LD(0,4,-1,4);
271   loadList[++k] = MK_LD(0,4,-1,4);
272   loadList[++k] = NULL;
273   loadList[++k] = NULL;
274 }
275 #endif
276
277 #ifdef arch_ia64_test
278 static const unsigned int nloads = 6;
279 static BPatch_memoryAccess* loadList[nloads];
280 static void init_test_data() {
281         loadList[0] = MK_LD( 0, 16, -1, 8 );
282         loadList[1] = MK_LD( 0, 14, -1, 8 );
283         loadList[2] = MK_LD( 0, 15, -1, 8 );
284         
285         loadList[3] = MK_LD( 0, 14, -1, 8 );
286         loadList[4] = MK_LD( 0, 14, -1, 16 );
287         loadList[5] = MK_LD( 0, 14, -1, 16 );
288 }
289 #endif
290
291 #ifdef arch_x86_64_test
292 static const unsigned int nloads = 75;
293
294 static BPatch_memoryAccess* loadList[nloads];
295
296 static void *divarwp, *dfvarsp, *dfvardp, *dfvartp, *dlargep;
297
298 static void get_vars_addrs(BPatch_image* bip) // from mutatee
299 {
300
301   BPatch_variableExpr* bpvep_diwarw = bip->findVariable("divarw");
302   BPatch_variableExpr* bpvep_diwars = bip->findVariable("dfvars");
303   BPatch_variableExpr* bpvep_diward = bip->findVariable("dfvard");
304   BPatch_variableExpr* bpvep_diwart = bip->findVariable("dfvart");
305   BPatch_variableExpr* bpvep_dlarge = bip->findVariable("dlarge");
306   divarwp = bpvep_diwarw->getBaseAddr();
307   dfvarsp = bpvep_diwars->getBaseAddr();
308   dfvardp = bpvep_diward->getBaseAddr();
309   dfvartp = bpvep_diwart->getBaseAddr();
310   dlargep = bpvep_dlarge->getBaseAddr();
311 }
312
313 static void init_test_data()
314 {
315   int k=-1;
316
317   // ModRM loads
318
319   // mod = 00
320   loadList[++k] = MK_LD(0,0,-1,4);
321   loadList[++k] = MK_LD(0,1,-1,8);
322   loadList[++k] = MK_LD(0,2,-1,4);
323   loadList[++k] = MK_LD(0,3,-1,8);
324   loadList[++k] = NULL; // rip-relative data access (disable the check)
325   loadList[++k] = MK_LD(0,6,-1,8);
326   loadList[++k] = MK_LD(0,7,-1,4);
327   loadList[++k] = MK_LD(0,8,-1,8);
328   loadList[++k] = MK_LD(0,9,-1,4);
329   loadList[++k] = MK_LD(0,10,-1,8);
330   loadList[++k] = MK_LD(0,11,-1,4);
331   loadList[++k] = MK_LD(0,14,-1,8);
332   loadList[++k] = MK_LD(0,15,-1,4);
333
334   // mod = 01
335   loadList[++k] = MK_LD(4,0,-1,4);
336   loadList[++k] = MK_LD(8,1,-1,8);
337   loadList[++k] = MK_LD(-4,2,-1,4);
338   loadList[++k] = MK_LD(-8,3,-1,8);
339   loadList[++k] = MK_LD(4,5,-1,4);
340   loadList[++k] = MK_LD(8,6,-1,8);
341   loadList[++k] = MK_LD(-4,7,-1,4);
342   loadList[++k] = MK_LD(-8,8,-1,8);
343   loadList[++k] = MK_LD(4,9,-1,4);
344   loadList[++k] = MK_LD(8,10,-1,8);
345   loadList[++k] = MK_LD(-4,11,-1,4);
346   loadList[++k] = MK_LD(-8,13,-1,8);
347   loadList[++k] = MK_LD(127,14,-1,4);
348   loadList[++k] = MK_LD(-128,15,-1,8);
349
350   // SIB loads
351   loadList[++k] = MK_LD(0,3,6,4);
352   loadList[++k] = MK_LD(0,4,-1,8);
353   loadList[++k] = MK_LDsc(0,3,1,1,4);
354   loadList[++k] = MK_LDsc((long)divarwp,-1,1,1,8);
355   loadList[++k] = MK_LD(4,3,1,4);
356   loadList[++k] = MK_LDsc((long)divarwp,2,2,3,8);
357   loadList[++k] = MK_LDsc(2,5,1,1,4);
358   loadList[++k] = MK_LDsc(4,3,1,2,8);
359   loadList[++k] = MK_LDsc((long)divarwp,5,1,2,4);
360
361   // loads from semantic test cases
362   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4); // inc
363   loadList[++k] = MK_LD((long)divarwp+4,-1,-1,4); // cmp
364   loadList[++k] = MK_LD2(0,6,-1,1,0,7,-1,1);      // cmpsb
365   loadList[++k] = MK_LS((long)divarwp,-1,-1,4);   // add
366   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4); // xchg
367   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,4); // imul
368   loadList[++k] = MK_LD((long)divarwp,-1,-1,4);   // imul
369   loadList[++k] = MK_LS((long)divarwp+4,-1,-1,4); // shld
370   loadList[++k] = MK_LD((long)divarwp,-1,-1,4);   // idiv
371
372   // MMX
373   loadList[++k] = MK_LD((long)divarwp,-1,-1,8);
374   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,8);
375
376   // SSE
377   loadList[++k] = MK_LD((long)dfvartp,-1,-1,16);
378   loadList[++k] = MK_LD((long)dfvartp,-1,-1,4);
379
380   // SSE2
381   loadList[++k] = MK_LD((long)dfvartp,-1,-1,16);
382   loadList[++k] = MK_LD((long)dfvartp,-1,-1,8);
383
384   // 3DNow!
385   loadList[++k] = MK_LD((long)dfvardp,-1,-1,8);
386   loadList[++k] = MK_LD((long)dfvardp+8,-1,-1,8);
387
388   // REP prefixes
389   loadList[++k] = MK_SL2vECX(0,7,-1,0,6,-1,2);
390   loadList[++k] = new BPatch_memoryAccess(NULL,0,
391                                           true, false,
392                                           0, 7, -1, 0,
393                                           0, -1, IA32_NESCAS, 0, 
394                                           -1, false);
395   loadList[++k] = new BPatch_memoryAccess(NULL,0,
396                                           true, false,
397                                           0, 6, -1, 0,
398                                           0, -1, IA32_ECMPS, 0,
399                                           true, false,
400                                           0, 7, -1, 0,
401                                           0, -1, IA32_ECMPS, 0);
402
403   // x87
404   loadList[++k] = MK_LD((long)dfvarsp,-1,-1,4);
405   loadList[++k] = MK_LD((long)dfvardp,-1,-1,8);
406   loadList[++k] = MK_LD((long)dfvartp,-1,-1,10);
407   loadList[++k] = MK_LD((long)divarwp,-1,-1,2);
408   loadList[++k] = MK_LD((long)divarwp+4,-1,-1,4);
409   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,8);
410
411   loadList[++k] = MK_LD((long)divarwp,-1,-1,2);
412   loadList[++k] = MK_LD((long)dlargep,-1,-1,28);
413
414   // conditional moves
415   loadList[++k] = MK_LDsccnd((long)divarwp,-1,-1,0,4,7); // cmova
416   loadList[++k] = MK_LDsccnd((long)divarwp+4,-1,-1,0,4,4); // cmove
417   loadList[++k] = MK_LD((long)divarwp+8,-1,-1,4);
418
419   // final 6 stack pops
420   loadList[++k] = MK_LD(0,4,-1,8);
421   loadList[++k] = MK_LD(0,4,-1,8);
422   loadList[++k] = MK_LD(0,4,-1,8);
423   loadList[++k] = MK_LD(0,4,-1,8);
424   loadList[++k] = MK_LD(0,4,-1,8);
425   loadList[++k] = MK_LD(0,4,-1,8);
426   // leave, return now touch memory
427   loadList[++k] = NULL;
428   loadList[++k] = NULL;
429 }
430 #endif
431
432
433 // Find and instrument loads with a simple function call snippet
434 // static int mutatorTest(BPatch_thread *appThread, BPatch_image *bpimg)
435 test_results_t test_mem_1_Mutator::executeTest() {
436   int testnum = 1;
437   const char* testdesc = "load instrumentation";
438 #if !defined(arch_sparc_test) && !defined(arch_power_test) && !defined(arch_x86_test) && !defined(arch_x86_64_test) && !defined(arch_ia64_test)
439   //skiptest(testnum, testdesc);
440   // Unsupported platform
441   return SKIPPED;
442 #else
443
444 #if defined(arch_x86_test) || defined(arch_x86_64_test)
445   get_vars_addrs(appImage);
446 #endif
447
448   dprintf("test_mem_1 is running\n");
449   init_test_data();
450   
451   BPatch_Set<BPatch_opCode> loads;
452   loads.insert(BPatch_opLoad);
453
454   BPatch_Vector<BPatch_function *> found_funcs;
455   const char *inFunction = "loadsnstores";
456   if ((NULL == appImage->findFunction(inFunction, found_funcs, 1)) || !found_funcs.size()) {
457     logerror("    Unable to find function %s\n", inFunction);
458     return FAILED;
459   }
460        
461   if (1 < found_funcs.size()) {
462     logerror("%s[%d]:  WARNING  : found %d functions named %s.  Using the first.\n", 
463             __FILE__, __LINE__, found_funcs.size(), inFunction);
464   }
465        
466   BPatch_Vector<BPatch_point *> *res1 = found_funcs[0]->findPoint(loads);
467
468   if(!res1)
469     failtest(testnum, testdesc, "Unable to find function \"loadsnstores\".\n");
470
471   dumpvect(res1, "Loads");
472
473   if((*res1).size() != nloads)
474   {
475     logerror("%s[%d]:  FAILURE: expected %d loads, got %d\n", __FILE__, __LINE__, nloads, (*res1).size());
476      failtest(testnum, testdesc, "Number of loads seems wrong in function \"loadsnstores.\"\n");   
477   }
478
479   if(!validate(res1, loadList, "load"))
480     failtest(testnum, testdesc, "Load sequence failed validation.\n");
481
482   if (instCall(appThread, "Load", res1) < 0) {
483     return FAILED;
484   }
485   return PASSED;
486 #endif
487 }
488
489 // External Interface
490 // extern "C" TEST_DLL_EXPORT int test6_1_mutatorMAIN(ParameterDict &param)
491 // {
492 //     BPatch *bpatch;
493 //     bpatch = (BPatch *)(param["bpatch"]->getPtr());
494 //     BPatch_thread *appThread = (BPatch_thread *)(param["appThread"]->getPtr());
495
496 //     // Get log file pointers
497 //     FILE *outlog = (FILE *)(param["outlog"]->getPtr());
498 //     FILE *errlog = (FILE *)(param["errlog"]->getPtr());
499 //     setOutputLog(outlog);
500 //     setErrorLog(errlog);
501
502 //     // Read the program's image and get an associated image object
503 //     BPatch_image *appImage = appThread->getImage();
504
505 //     // Run mutator code
506 //     return mutatorTest(appThread, appImage);
507 // }