Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test1_37_mutatee.c
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include "mutatee_util.h"
32
33 /* group_mutatee_boilerplate.c is prepended to this file by the make system */
34
35 /* Externally accessed function prototypes.  These must have globally unique
36  * names.  I suggest following the pattern <testname>_<function>
37  */
38
39 void test1_37_call1();
40 void test1_37_call2();
41 void test1_37_call3();
42 void test1_37_inc1();
43 void test1_37_inc2();
44 void test1_37_inc3();
45
46 /* Global variables accessed by the mutator.  These must have globally unique
47  * names.
48  */
49
50 /* Internally used function prototypes.  These should be declared with the
51  * keyword static so they don't interfere with other mutatees in the group.
52  */
53
54 /* Global variables used internally by the mutatee.  These should be declared
55  * with the keyword static so they don't interfere with other mutatees in the
56  * group.
57  */
58
59 static volatile int globalVariable37_1 = 0;
60 static volatile int globalVariable37_2 = 0;
61 static volatile int globalVariable37_3 = 0;
62
63 /* Function definitions follow */
64
65 /* Test #37 (loop instrumentation) */
66
67 int test1_37_mutatee() {
68 /* Alpha is no longer supported, so I'm commenting out this check
69  * #if defined(os_osf_test)
70  *    passedTest [ 37 ] = TRUE;
71  *    logerror( "Skipped test #37 (instrument loops)\n" );
72  *    logerror( "\t- known to be a problem on this platform-- hah!\n" );
73  * #else
74  */
75   int failed = FALSE;
76
77     const int ANSWER37_1 = 11002;
78     const int ANSWER37_2 = 26;
79     const int ANSWER37_3 = 752;
80
81     test1_37_call1();
82     test1_37_call2();
83     test1_37_call3();
84
85     if (globalVariable37_1 != ANSWER37_1) {
86       failed = TRUE;
87         logerror( "**Failed** test #37 (instrument loops)\n");
88         logerror( "  globalVariable37_1 is %d, should have been %d.\n",
89                 globalVariable37_1, ANSWER37_1);
90     }
91     if (globalVariable37_2 != ANSWER37_2) {
92       failed = TRUE;
93         logerror( "**Failed** test #37 (instrument loops)\n");
94         logerror( "  globalVariable37_2 is %d, should have been %d.\n",
95                 globalVariable37_2, ANSWER37_2);
96     } 
97     if (globalVariable37_3 != ANSWER37_3) {
98       failed = TRUE;
99         logerror( "**Failed** test #37 (instrument loops)\n");
100         logerror( "  globalVariable37_3 is %d, should have been %d.\n",
101                 globalVariable37_3, ANSWER37_3);
102     } 
103     
104     if (FALSE == failed) {
105         logerror( "Passed test #37 (instrument loops)\n" );
106         test_passes(testname);
107         return 0; /* Test passed */
108     } else {
109       return -1; /* Test failed */
110     }
111
112 /* #endif /* !Alpha */
113 }
114
115 void test1_37_inc1() { globalVariable37_1++; }
116         
117 /* At the end of normal execution, globalVariable37_1 should
118    hold 100 + 500 + ( 100 * 10 ) + ( 100 * 10 * 7 ) = 8600
119     
120    If we instrument the entry and exit edge of each loop with a call
121    to test1_37_inc1, globalVariable37_1 should be increased by
122    2 + ( 2 * 100 ) + ( 2 * 100 * 10 ) + ( 2 * 100 ) = 2402
123         
124    Successful loop edge instrumentation will give us a value of 11002.
125 */  
126 void test1_37_call1() {
127     int i, j, k, m;
128
129     for (i = 0; i < 100; i++) {
130         globalVariable37_1++;
131
132         for (j = 0; j < 10; j++) {
133             globalVariable37_1++;
134             
135             for (k = 0; k < 7; k++) {
136                 globalVariable37_1++;
137             }
138         }
139         
140         m = 0;
141         do {
142             globalVariable37_1++;
143             m++;
144         } while (m < 5);
145     }
146 }
147
148 void test1_37_inc2() { globalVariable37_2++; }
149
150 /* At the end of normal execution, globalVariable37_2 should
151    hold 20.
152    If we instrument the entry and exit edge of each loop with a call
153    to test1_37_inc2, globalVariable37_2 should be increased by
154    2 + 2 + 2 = 6
155
156    Successful loop edge instrumentation will give us a value of 26.
157 */
158
159 /* The comment below is no longer relevant, but has been left in as an
160  explanation of how this test arose. The original mechanism for testing
161  loops (instrumenting some arbitrary block in the body that was expected
162  to execute a certain number of times was fundamentally flawed, for
163  reasons that will become apparent with a little thought. We're leaving
164  these tests in, though, in the hopes that the compiler will produce
165  different loop idioms and thus stress-test our loop detection code.
166 */
167
168 /* test with small loop bodies. since there are no statements right after the
169    start of the outer two loops there isn't much space to instrument. */
170 void test1_37_call2() {                
171     volatile int i = 0;
172     volatile int j = 0;
173     volatile int k = 0;
174     
175     while (i < 5) {
176         while (j < 10) {
177             do {
178                 globalVariable37_2++;
179                 i++; j++; k++;
180             } while (k < 20);
181         }
182     }
183 }
184
185
186 void test1_37_inc3() { globalVariable37_3++; }
187
188 /* At the end of normal execution, globalVariable37_3 should
189    hold 100 / 2 + (100 / 2 ) * 10 = 550
190    
191    If we instrument the entry and exit edge of each loop with a call
192    to test1_37_inc3, globalVariable37_3 should be increased by
193    2 * 100 + 2 = 202
194
195    Successful loop edge instrumentation will give us a value of 752.
196 */
197
198 /* test with if statements as the only statements in a loop body. */
199 void test1_37_call3() {
200     volatile int i, j;
201
202     for (i = 0; i < 100; i++) {
203         if (0 == (i % 2)) {
204             globalVariable37_3++;
205         }
206         for (j = 0; j < 10; j++) {
207             if (0 == (i % 2)) {
208                 globalVariable37_3++;
209             }
210         }
211     }
212 }