Update copyright to LGPL on all files
[dyninst.git] / codeCoverage / h / CodeCoverage.h
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 #ifndef _CodeCoverage_h_
33 #define _CodeCoverage_h_
34
35 #include "BPatch.h"
36 #include "BPatch_Vector.h"
37 #include "BPatch_image.h"
38 #include "BPatch_module.h"
39 #include "BPatch_thread.h"
40
41 class FunctionCoverage;
42 class FileLineInformation;
43 class FileLineCoverage;
44
45 /** class to run code coverage on a mutatee program.
46   * This class is responsible for selecting the functions
47   * to be instrumented ( source code line information availability)
48   * and then instruments each function either using all basic blocks 
49   * or using dominator information.
50   * This class contains array of functions that will be instrumented
51   */
52 class CodeCoverage {
53 protected:
54         /** bpatch object of the mutatee */
55         BPatch bPatch;
56
57         /** thread of the mutatee */
58         BPatch_thread *appThread;
59
60         /** image of the mutatee */
61         BPatch_image *appImage;
62
63         /** output file name where the coverage results are
64           * written as a binary file 
65           */
66         char* coverageFileName;
67
68         /** output file descriptor */
69    std::ofstream coverageFile;
70
71         /** the time between intervals in seconds */
72         unsigned short deletionInterval;
73
74         /** modules in the mutatee program */
75         BPatch_Vector<BPatch_module*>* appModules;
76
77         /** array of function records that will be instrumented
78           * or possible to instrument
79           */
80         FunctionCoverage** instrumentedFunctions;
81
82         /** number of the functions that might be instrumented*/
83         int instrumentedFunctionCount;
84
85         /** flag to identify whether dominator information
86           * will be used for instrumentation or not
87           */
88         bool useDominator;
89
90         /** the output file name is generated by adding a suffix
91           * to the name of the executable. this field stores
92           * the extension. The default value is ".dyncov"
93           */
94         char* FILE_EXTENSION;
95
96         /** pointer to the global object used for interval callback */
97         static CodeCoverage* globalObject;
98
99         /** array to represent files in the executable 
100           * sorted by fileName. Each entry in the array
101           * stores index to the entry in array of CodeCoverage records
102           * Note that CodeCoverage records are sorted according to
103           * file name and then function name
104           */
105         static unsigned short fileCount;
106         static unsigned short* fileStartIndex;
107         static unsigned short* fileLineCount;
108         static FileLineCoverage** fileLineCoverage;
109
110         Tcl_Interp* globalInterp;
111         const char* statusBarName;
112
113         unsigned short whichInterval;
114         unsigned short totalDeletions;
115         unsigned short totalCoveredLines;
116
117         pthread_mutex_t statusUpdateLock;
118         bool tclStatusChanged;
119         char tclStatusBuffer[1024];
120
121 protected:
122         friend class FunctionCoverage;
123
124         /** method to validate whether function has its 
125           * source code line information available or not
126           * @param funcN name of the function
127           * @param min the minimum address of the line info records
128           *        of the function
129           */
130         BPatch_function* validateFunction(const char* funcN,
131                                           unsigned long min);
132
133         /** creates a new object of FunctionCoverage for the
134           * given function
135           * @param f function that is assigned to FunctionCoverage object
136           * @param funcN name of the function
137           * @param fileN name of the source file function is defined in
138           */
139         FunctionCoverage* newFunctionCoverage(BPatch_function* f,
140                                 const char* funcN, FileLineCoverage* fileN);
141
142         /** method to print error message of this class */
143         static int errorPrint(int code,char* text=NULL);
144
145         /** method to print coverage results to the output file */
146         int printCoverageInformation();
147
148         /** method to update execution counts kept in FunctionCoverage
149           * objects for executed functions and basic blocks.
150           */
151         int updateFCObjectInfo();
152
153         /** interval callback */
154         virtual int deletionIntervalCallback();
155
156         /** method that returns whether a function is executed/instrumented
157           * during the execution of the mutatee. 
158           * @param i identifier of the function in the array
159           */
160         virtual bool isInstrumented(int i);
161
162         /** method that creates an array of files in the executable*/
163         void createFileStructure();
164
165 public:
166         pthread_mutex_t updateLock;
167
168         /** constructor of the class */
169         CodeCoverage();
170
171         /** method that initialize the field of the class
172           * @param mutatee program to run
173           * @param interval time between intervals
174           * @param dominatorInfo flag whether dominator info will be used
175           * @param suffix the exetension to the exec file name to print results
176           */
177         int initialize(const char* mutatee[],unsigned short interval=0,
178                        bool dominatorInfo=false,const char* suffix=".dyncov");
179
180         /** method to select functions that will be possibly instrumented
181           * during the execution of mutatee (source code line information).
182           */
183         int selectFunctions();
184
185         /** method to instrument break point to the exit point of mutatee*/
186         int instrumentExitHandle();
187
188         /** method to initially instrument functions before the mutatee
189           * starts running. For preInstrumentation all functions are
190           * instrumented and for ondemand instrumentation only break
191           * points are inserted to the entry points
192           */
193         virtual int instrumentInitial(); 
194
195         /** method to execute the mutatee and checking the coverage
196           * results in fixed time intervals
197           */
198         virtual int run();
199
200         /** method to clean data structures in case of error */
201         void terminate();
202
203         /** method to register error call back function */
204         BPatchErrorCallback registerErrorCallback(BPatchErrorCallback f);
205
206         /** method to read the coverage results from the given file 
207           * and print in ascii to the standard output
208           * @param fN file name of the binary output file
209           */
210         static int viewCodeCoverageInfo(char* fN);
211
212         /** method that prints the tcl/tk command to create
213           * global data structure to be used for menu/list creation
214           */
215         void getTclTkMenuListCreation(std::ofstream& file);
216  
217         /** method that retrieves all executed line information
218           */
219         void getTclTkExecutedLines(std::ofstream& file);
220
221         /** method that prints deletions and executed lines to a file
222           */
223         void addTclTkFrequency();
224
225         /** method to set tcl/tk related things to CodeCoverage */
226         void setTclTkSupport(Tcl_Interp* interp,const char* statusBar);
227
228         /** method that prepares the file for menu creation for view only */
229         static int getTclTkMenuListForView(char* fN,std::ofstream& file);
230
231         bool getTclStatusUpdateString(char* buffer,int length);
232
233         /** destructor of the class */
234         virtual ~CodeCoverage();
235 };
236
237 #endif /* _CodeCoverage_h_ */