isLeaf() --> hasNoStackFrame() for instPoint and pd_Function
[dyninst.git] / dyninstAPI / tests / src / test1.mutatee.c
1
2 /* Test application (Mutatee) */
3
4 #include <stdio.h>
5 #include <sys/types.h>
6 #include <signal.h>
7 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
8 #include <unistd.h>
9 #endif
10
11 /* XXX Currently, there's a bug in the library that prevents a subroutine call
12  * instrumentation point from being recognized if it is the first instruction
13  * in a function.  The following variable is used in this program in a number
14  * of kludges to get around this.
15  */
16 int kludge;
17
18 // control debug printf statements
19 #define dprintf if (debugPrint) printf
20 int debugPrint = 0;
21
22 #define TRUE    1
23 #define FALSE   0
24
25 int globalVariable1_1 = 0;
26 int globalVariable3_1 = 31;
27 int globalVariable4_1 = 41;
28 int globalVariable5_1 = 51;
29 int globalVariable5_2 = 51;
30
31 int globalVariable6_1 = 0xdeadbeef;
32 int globalVariable6_2 = 0xdeadbeef;
33 int globalVariable6_3 = 0xdeadbeef;
34 int globalVariable6_4 = 0xdeadbeef;
35 int globalVariable6_5 = 0xdeadbeef;
36 int globalVariable6_6 = 0xdeadbeef;
37
38 int globalVariable7_1 = 71, globalVariable7_2 = 71,
39     globalVariable7_3 = 71, globalVariable7_4 = 71,
40     globalVariable7_5 = 71, globalVariable7_6 = 71,
41     globalVariable7_7 = 71, globalVariable7_8 = 71,
42     globalVariable7_9 = 71, globalVariable7_10 = 71,
43     globalVariable7_11 = 71, globalVariable7_12 = 71,
44     globalVariable7_13 = 71, globalVariable7_14 = 71,
45     globalVariable7_15 = 71, globalVariable7_16 = 71;
46
47
48 int globalVariable8_1 = 1;
49
50 int globalVariable10_1 = 0, globalVariable10_2 = 0, 
51     globalVariable10_3 = 0, globalVariable10_4 = 0;
52
53 int globalVariable11_1 = 0, globalVariable11_2 = 0, 
54     globalVariable11_3 = 0, globalVariable11_4 = 0, globalVariable11_5 = 0;
55
56 int globalVariable12_1 = 0;
57
58 int globalVariable13_1 = 0;
59
60 int globalVariable14_1 = 0;
61 int globalVariable14_2 = 0;
62
63 int globalVariable15_1 = 0;
64 int globalVariable15_2 = 0;
65 int globalVariable15_3 = 0;
66
67 int globalVariable16_1 = 0;
68 int globalVariable16_2 = 0;
69 int globalVariable16_3 = 0;
70 int globalVariable16_4 = 0;
71
72
73 void call1_1()
74 {
75     dprintf("call1() called - setting globalVariable1_1 = 11\n");
76     globalVariable1_1 = 11;
77 }
78
79 void call2_1(int arg1, int arg2, char *arg3)
80 {
81     if ((arg1 == 1) && (arg2 == 2) && (!strcmp(arg3, "testString2_1"))) {
82         printf("Passed test #2 (three parameter function)\n");
83     } else {
84         printf("**Failed** test #2 (three parameter function)\n");
85         if (arg1 != 1) 
86             printf("    arg1 = %d, should be 1\n", arg1);
87         if (arg1 != 2) 
88             printf("    arg2 = %d, should be 2\n", arg2);
89         if (strcmp(arg3, "testString2_1")) 
90             printf("    arg3 = %s, should be \"testString2_1\"\n", arg3);
91     }
92 }
93
94 void call3_1(int arg1, int arg2)
95 {
96     if ((arg1 == 31) && (arg2 == 32))  {
97         printf("Passed test #3 (passing variables to functions)\n");
98     } else {
99         printf("**Failed** test #3 (passing variables to functions)\n");
100         printf("    arg1 = %d, should be 31\n", arg1);
101         printf("    arg2 = %d, should be 32\n", arg2);
102     }
103 }
104
105 int call9_1(int p1, int p2, int p3, int p4, int p5)
106 {
107     int x; 
108     x = (((p1 + p2) + (p3 + p4) + (p5)));
109     if (x != (91 + 92 + 93 + 94 + 95 )) {
110       printf("**Failed** test case #9 (preserve registers - funcCall)\n");
111       if (p1 != 91) printf("    call9_1 parameter 1 is %d not 91\n", p1);
112       if (p2 != 92) printf("    call9_1 parameter 2 is %d not 92\n", p2);
113       if (p3 != 93) printf("    call9_1 parameter 2 is %d not 93\n", p3);
114       if (p4 != 94) printf("    call9_1 parameter 4 is %d not 94\n", p4);
115       if (p5 != 95) printf("    call9_1 parameter 5 is %d not 95\n", p5);
116       exit(-1);
117     }
118     dprintf("inside call9_1\n");
119     return x;
120 }
121
122 void call10_1()
123 {
124     if (globalVariable10_4 == 0) {
125         globalVariable10_4 = 1; // update marker of call order
126         globalVariable10_1 = 1; // flag that this was called first
127     }
128 }
129
130
131 void call10_2()
132 {
133     if (globalVariable10_4 == 1) {
134         globalVariable10_4 = 2; // update marker of call order
135         globalVariable10_2 = 1; // flag that this was called first
136     }
137 }
138
139 void call10_3()
140 {
141     if (globalVariable10_4 == 2) {
142         globalVariable10_4 = 3; // update marker of call order
143         globalVariable10_3 = 1; // flag that this was called first
144     }
145 }
146
147 void call11_1()
148
149     if (globalVariable11_1 == 0) globalVariable11_2 = 1;
150 }
151
152 void call11_2()
153
154     if (globalVariable11_1 == 1) globalVariable11_3 = 1;
155 }
156
157 void call11_3()
158
159     if (globalVariable11_1 == 2) globalVariable11_4 = 1;
160 }
161
162 void call11_4()
163
164     if (globalVariable11_1 == 3) globalVariable11_5 = 1;
165
166     if (globalVariable11_2 && globalVariable11_3 && 
167         globalVariable11_4 && globalVariable11_5) {
168         printf("Passed test #11 (snippets at entry,exit,call)\n");
169     } else {
170         printf("**Failed test #11 (snippets at entry,exit,call)\n");
171         if (!globalVariable11_2) 
172             printf("    entry snippet not called at the correct time\n");
173         if (!globalVariable11_3) 
174             printf("    pre call snippet not called at the correct time\n");
175         if (!globalVariable11_4) 
176             printf("    post call snippet not called at the correct time\n");
177         if (!globalVariable11_5) 
178             printf("    exit snippet not called at the correct time\n");
179     }
180 }
181
182 void call12_1()
183 {
184     globalVariable12_1++;
185 }
186
187 void call13_1(int a1, int a2, int a3, int a4, int a5)
188 {
189     if (a1 == 131) globalVariable13_1 |= 1;
190     if (a2 == 132) globalVariable13_1 |= 2;
191     if (a3 == 133) globalVariable13_1 |= 4;
192     if (a4 == 134) globalVariable13_1 |= 8;
193     if (a5 == 135) globalVariable13_1 |= 16;
194     dprintf("a1 = %d\n", a1);
195     dprintf("a2 = %d\n", a2);
196     dprintf("a3 = %d\n", a3);
197     dprintf("a4 = %d\n", a4);
198     dprintf("a5 = %d\n", a5);
199 }
200
201 void call14_1()
202 {
203     globalVariable14_1 = 1;
204 }
205
206 void call15_1()
207 {
208     globalVariable15_1++;
209 }
210
211 void call15_2()
212 {
213     globalVariable15_2++;
214 }
215
216 void call15_3()
217 {
218     globalVariable15_3++;
219 }
220
221 //
222 // This is a series of nearly empty functions to attach code to 
223 //
224 void func1_1() { dprintf("func1_1 () called\n"); }
225 void func2_1() { dprintf("func2_1 () called\n"); }
226 void func3_1() { dprintf("func3_1 () called\n"); }
227 void func4_1() { dprintf("func4_1 () called\n"); }
228 void func5_1() { dprintf("func5_1 () called\n"); }
229 void func6_1() { dprintf("func7_1 () called\n"); }
230 void func7_1() { dprintf("func7_1 () called\n"); }
231
232 void func8_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
233              int p8, int p9, int p10)
234 {
235     dprintf("func8_1 (...) called\n");
236     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) && 
237         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
238         printf("Passed test #8 (preserve registers - expr)\n");
239     } else {
240         printf("**Failed** test #8 (preserve registers - expr )\n");
241         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
242         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
243         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
244         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
245         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
246         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
247         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
248         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
249         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
250         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
251     }
252 }
253
254 void func9_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
255              int p8, int p9, int p10)
256 {
257     dprintf("func9_1 (...) called\n");
258     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) && 
259         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
260         printf("Passed test #9 (preserve registers - funcCall)\n");
261     } else {
262         printf("**Failed** test #9 (preserve registers - funcCall )\n");
263         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
264         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
265         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
266         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
267         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
268         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
269         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
270         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
271         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
272         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
273     }
274 }
275
276 void func10_1()
277 {
278     if ((globalVariable10_1 == 1) && (globalVariable10_2 == 1) && 
279         (globalVariable10_3 == 1) && (globalVariable10_4 == 3)) {
280         printf("Passed test #10 (insert snippet order)\n");
281     } else {
282         printf("** Failed test #10 (insert snippet order)\n");
283         if (!globalVariable10_1) 
284             printf("    call10_1 was not called first\n");
285         if (!globalVariable10_2) 
286             printf("    call10_2 was not called second\n");
287         if (!globalVariable10_3) 
288             printf("    call10_3 was not called third\n");
289     }
290 }
291
292 void func11_2() {
293     globalVariable11_1 = 2;
294 }
295
296 void func11_1()
297 {
298     globalVariable11_1 = 1;
299     func11_2();
300     globalVariable11_1 = 3;
301 }
302
303 void func12_2()
304 {
305 }
306
307 void func12_1()
308 {
309     func12_2();
310     kill(getpid(), SIGSTOP);
311     func12_2();
312     if (globalVariable12_1 == 1) {
313         printf("Passed test #12 (insert/remove and malloc/free)\n");
314     } else {
315         printf("**Failed test #12 (insert/remove and malloc/free)\n");
316     }
317 }
318
319 void func13_1(int p1, int p2, int p3, int p4, int p5)
320 {
321     if ((p1 == 131) && (p2 == 132) && (p3 == 133) && 
322         (p4 == 134) && (p5 == 135) && (globalVariable13_1 == 31)) {
323         printf("Passed test #13 (paramExpr,nullExpr)\n");
324     } else {
325         printf("**Failed test #13 (paramExpr,nullExpr)\n");
326         if (p1 != 131) printf("  parameter 1 is %d, not 131\n", p1);
327         if (p2 != 132) printf("  parameter 2 is %d, not 132\n", p2);
328         if (p3 != 133) printf("  parameter 3 is %d, not 133\n", p3);
329         if (p4 != 134) printf("  parameter 4 is %d, not 134\n", p4);
330         if (p5 != 135) printf("  parameter 5 is %d, not 135\n", p5);
331         if (!(globalVariable13_1 & 1)) printf("    passed param a1 wrong\n");
332         if (!(globalVariable13_1 & 2)) printf("    passed param a2 wrong\n");
333         if (!(globalVariable13_1 & 4)) printf("    passed param a3 wrong\n");
334         if (!(globalVariable13_1 & 8)) printf("    passed param a4 wrong\n");
335         if (!(globalVariable13_1 & 16)) printf("    passed param a5 wrong\n");
336     }
337 }
338
339
340 void func14_2()
341 {
342     globalVariable14_1 = 2;
343 }
344
345 void func14_3()
346 {
347     globalVariable14_2 = 1;
348 }
349
350 void func14_1()
351 {
352     kludge = 1; // Here so that the following function call isn't the first
353                 // instruction
354
355     func14_2();
356     func14_3();
357
358     if (globalVariable14_1 == 1 && globalVariable14_2 == 0) {
359         printf("Passed test #14 (replace/remove function call)\n");
360     } else {
361         printf("**Failed test #14 (replace/remove function call)\n");
362         if (globalVariable14_1 != 1)
363             printf("    call to func14_2() was not replaced\n");
364         if (globalVariable14_2 != 0)
365             printf("    call to func14_3() was not removed\n");
366     }
367 }
368
369
370 void check15result(char *varname, int value, int expected,
371                    char *errstr, int *failed)
372 {
373     if (value != expected) {
374         if (!*failed)
375             printf("**failed test #15 (setMutationsActive)\n");
376         *failed = TRUE;
377
378         printf("    %s = %d %s\n", varname, value, errstr);
379     }           
380 }
381
382
383 void func15_2()
384 {
385 }
386
387 void func15_3()
388 {
389     globalVariable15_3 = 100;
390 }
391
392 void func15_4()
393 {
394     kludge = 1; // Here so that the following function call isn't the first
395                 // instruction
396
397     func15_3();
398 }
399
400
401 void func15_1()
402 {
403     int failed = FALSE;
404
405     func15_2();
406     check15result("globalVariable15_1", globalVariable15_1, 1,
407                   "after first call to instrumented function", &failed);
408
409 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
410     // Test a function that makes a system call (is a special case on Sparc)
411     access(".", R_OK);
412     check15result("globalVariable15_2", globalVariable15_2, 2,
413                   "after first call to instrumented function", &failed);
414 #endif
415
416     func15_4();
417     check15result("globalVariable15_3", globalVariable15_3, 1,
418                   "after first call to instrumented function", &failed);
419
420     /***********************************************************/
421
422     kill(getpid(), SIGSTOP);
423
424     func15_2();
425     check15result("globalVariable15_1", globalVariable15_1, 1,
426                   "after second call to instrumented function", &failed);
427
428 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
429     access(".", R_OK);
430     check15result("globalVariable15_2", globalVariable15_2, 2,
431                   "after second call to instrumented function", &failed);
432 #endif
433
434     func15_4();
435     check15result("globalVariable15_3", globalVariable15_3, 100,
436                   "after second call to instrumented function", &failed);
437
438     /***********************************************************/
439
440     kill(getpid(), SIGSTOP);
441
442     func15_2();
443     check15result("globalVariable15_1", globalVariable15_1, 2,
444                   "after third call to instrumented function", &failed);
445
446 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
447     access(".", R_OK);
448     check15result("globalVariable15_2", globalVariable15_2, 4,
449                   "after third call to instrumented function", &failed);
450 #endif
451
452     func15_4();
453     check15result("globalVariable15_3", globalVariable15_3, 101,
454                   "after third call to instrumented function", &failed);
455
456     if (!failed) {
457         printf("Passed test #15 (setMutationsActive)\n");
458     }
459 }
460
461
462 void func16_2() { dprintf("func16_2 () called\n"); }
463 void func16_3() { dprintf("func16_3 () called\n"); }
464
465 void func16_1()
466 {
467     int failed = 0;
468
469     func16_2();
470     if (globalVariable16_1 != 1 || globalVariable16_2 != 0) {
471         printf("**Failed test #16 (if-else)\n");
472         if (globalVariable16_1 != 1)
473             printf("    True clause of first if should have been executed but was not.\n");
474         if (globalVariable16_2 != 0)
475             printf("    False clause of first if should not have been executed but was.\n");
476         failed = 1;
477     }
478
479     func16_3();
480     if (globalVariable16_3 != 0 || globalVariable16_4 != 1) {
481         printf("**Failed test #16 (if-else)\n");
482         if (globalVariable16_3 != 1)
483             printf("    True clause of second if should not have been executed but was.\n");
484         if (globalVariable16_4 != 0)
485             printf("    False clause of second if should have been executed but was not.\n");
486         failed = 1;
487     }
488
489     if (!failed)
490         printf("Passed test #16 (if-else)\n");
491 }
492
493
494 void fail7Print(int tCase, int fCase, char *op)
495 {
496     if (tCase != 72) 
497         printf(" operator %s was not true when it should be\n", op); 
498     if (fCase != 71) 
499         printf(" operator %s was not false when it should be\n", op); 
500 }
501
502 void main(int argc, char *argv[])
503 {
504     if (argc == 2 && !strcmp(argv[1], "-verbose")) {
505         debugPrint = 1;
506     }
507
508     // Test #1
509     dprintf("Value of globalVariable1_1 is %d.\n", globalVariable1_1);
510     func1_1();
511     dprintf("Value of globalVariable1_1 is now %d.\n", globalVariable1_1);
512
513     if (globalVariable1_1 == 11)
514         printf("\nPassed test #1 (zero arg function call)\n");
515     else
516         printf("\n**Failed** test #1 (zero arg function call)\n");
517
518     // Test #2
519     func2_1();
520
521     // Test #3 
522     func3_1();
523
524     // Test #4
525     func4_1();
526     if (globalVariable4_1 == 41) {
527         printf("**Failed** test #4 (sequence)\n");
528         printf("    none of the items were executed\n");
529     } else if (globalVariable4_1 == 42) {
530         printf("**Failed** test #4 (sequence)\n");
531         printf("    first item was the last (or only) one to execute\n");
532     } else if (globalVariable4_1 == 43) {
533         printf("Passed test #4 (sequence)\n");
534     }
535
536     // test #5
537     func5_1();
538     if ((globalVariable5_1 == 51) && (globalVariable5_2 == 53)) {
539         printf("Passed test #5 (if w.o. else)\n");
540     } else {
541         printf("**Failed** test #5 (if w.o. else)\n");
542         if (globalVariable5_1 != 51) {
543             printf("    condition executed for false\n");
544         }
545         if (globalVariable5_2 != 53) {
546             printf("    condition not executed for true\n");
547         }
548     }
549
550     func6_1();
551     if ((globalVariable6_1 == 60+2) && (globalVariable6_2 == 64-1) &&
552         (globalVariable6_3 == 66/3) && (globalVariable6_4 == 67/3) &&
553         (globalVariable6_5 == 6 * 5) && (globalVariable6_6 == 3)) {
554         printf("Passed test #6 (arithmetic operators)\n");
555     } else {
556         printf("**Failed** test #6 (arithmetic operators)\n");
557         if (globalVariable6_1 != 60+2) 
558             printf("    addition error 60+2 got %d\n", globalVariable6_1);
559         if (globalVariable6_2 != 64-1) 
560             printf("    subtraction error 64-1 got %d\n", globalVariable6_2);
561         if (globalVariable6_3 != 66/3)
562             printf("    division error 66/3 got %d\n", globalVariable6_3);
563         if (globalVariable6_4 != 67/3)
564             printf("    division error 67/3 got %d\n", globalVariable6_4);
565         if (globalVariable6_5 != 6 * 5)
566             printf("    mult error 6*5 got %d\n", globalVariable6_5);
567         if (globalVariable6_6 != 3)
568             printf("    mod error 10,3 got %d\n", globalVariable6_6);
569     }
570
571     func7_1();
572     if ((globalVariable7_1 == 72) && (globalVariable7_2 == 71) &&
573         (globalVariable7_3 == 72) && (globalVariable7_4 == 71) &&
574         (globalVariable7_5 == 72) && (globalVariable7_6 == 71) &&
575         (globalVariable7_7 == 72) && (globalVariable7_8 == 71) &&
576         (globalVariable7_9 == 72) && (globalVariable7_10 == 71) &&
577         (globalVariable7_11 == 72) && (globalVariable7_12 == 71) &&
578         (globalVariable7_13 == 72) && (globalVariable7_14 == 71) &&
579         (globalVariable7_15 == 72) && (globalVariable7_16 == 71)) { 
580         printf("Passed test #7 (relational operators)\n");
581     } else {
582         printf("**Failed** test #7 (relational operators)\n");
583         fail7Print(globalVariable7_1, globalVariable7_2, "BPatch_lt");
584         fail7Print(globalVariable7_3, globalVariable7_4, "BPatch_eq");
585         fail7Print(globalVariable7_5, globalVariable7_6, "BPatch_gt");
586         fail7Print(globalVariable7_7, globalVariable7_8, "BPatch_le");
587         fail7Print(globalVariable7_9, globalVariable7_10, "BPatch_ne");
588         fail7Print(globalVariable7_11, globalVariable7_12, "BPatch_ge");
589         fail7Print(globalVariable7_13, globalVariable7_14, "BPatch_and");
590         fail7Print(globalVariable7_15, globalVariable7_16, "BPatch_or");
591     }
592
593     func8_1(1,2,3,4,5,6,7,8,9,10);
594
595     func9_1(1,2,3,4,5,6,7,8,9,10);
596
597     func10_1();
598
599     func11_1();
600
601     func12_1();
602
603     func13_1(131,132,133,134,135);
604
605     func14_1();
606
607     func15_1();
608
609     func16_1();
610
611     exit(0);
612 }