Update copyright to LGPL on all files
[dyninst.git] / codeCoverage / h / FunctionCoverage.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 _FunctionCoverage_h_
33 #define _FunctionCoverage_h_
34
35 #include "BPatch.h"
36 #include "BPatch_Vector.h"
37 #include "BPatch_image.h"
38 #include "BPatch_module.h"
39 #include "BPatch_point.h"
40 #include "BPatch_snippet.h"
41 #include "BPatch_thread.h"
42 #include "BPatch_flowGraph.h"
43 #include <fstream>
44
45 class FunctionCoverage;
46
47 /** class to represent the instrumentation of a function 
48   * during code coverage. It also keeps data structures 
49   * to store the control flow graph, execution counts of the
50   * basic blocks of the function. It is the base class for 
51   * two classes that either does all basic block instrumentation
52   * or use dominator information during instrumentation
53   */
54 class FileLineCoverage {
55         friend class CodeCoverage;
56         friend class FunctionCoverage;
57         friend int FCSortByFileName(const void* arg1,const void* arg2);
58         friend int FLSortByFileName(const void* arg1,const void* arg2);
59
60 protected:
61         FunctionCoverage* owner;
62         /** source file name the function is in */
63         const char* fileName;
64
65         unsigned short lineCount;
66         BPatch_Set<unsigned short> executedLines;
67         BPatch_Set<unsigned short> unExecutedLines;
68
69         float executionPercentage;
70 public:
71         FileLineCoverage(const char*);
72         void initializeLines(BPatch_Set<unsigned short>&);
73         void setOwner(FunctionCoverage*);
74         static FileLineCoverage* findFile(FileLineCoverage**,int,const char*);
75         ~FileLineCoverage();
76 };
77         
78 class FunctionCoverage {
79 protected:
80         /** function to be instrumented */
81         BPatch_function* bpFunction;
82         
83         /** the thread function belongs to */
84         BPatch_thread* appThread;
85         
86         /** image the function belongs to */
87         BPatch_image* appImage;
88
89         /** control flow graph of the function */
90         BPatch_flowGraph* cfg;
91
92         /** number of instrumentation code that is inserted */
93         int instrumentationCount;
94
95         /** the basic blocks that are instrumented */
96         BPatch_basicBlock** instrumentedBlock;
97
98         /** variables assigned to basic blocks */
99         BPatch_variableExpr** blockVariable;
100
101         /** instrumentation code inserted for each basic block*/
102         BPatchSnippetHandle** instrumentationCode;
103
104         /** instrumentation counts for all basic blocks */
105         int* executionCounts;
106
107         /** name of the function */
108         const char* functionName;
109
110         /* the id of the function */
111         int id;
112
113         /** all blocks in the control flow graph */
114         BPatch_Set<BPatch_basicBlock*> allBlocks;
115
116         /** entry blocks in the control flow graph */
117         BPatch_Set<BPatch_basicBlock*> entryBlock;
118
119         /** exit blocks in the control flow graph */
120         BPatch_Set<BPatch_basicBlock*> exitBlock;
121
122         bool isPrecise;
123
124         int sourceFileLinesCount;
125         FileLineCoverage** sourceFileLines;
126
127 public:
128         /** friend class */
129         friend class CCOnDemandInstrument;
130         friend class CodeCoverage;
131         
132         /** friend function that is used to sort Function Coverage 
133           * objects according to the function names
134           */
135         friend int FCSortByFileName(const void* arg1,const void* arg2);
136         friend int FLSortByFileName(const void* arg1,const void* arg2);
137
138 protected:
139         /** method to print error message for this class */
140         static int errorPrint(int code,char* text=NULL);
141
142         /** method that initializes the dominator information 
143           * of the control flow graph
144           */
145         virtual void fillDominatorInfo();
146
147         /** method to validate whether a basic blocks is 
148           * needed to be instrumented or not.
149           * @param bb basic block pointer
150           */
151         virtual bool validateBasicBlock(BPatch_basicBlock* bb);
152
153         /** method to update the execution counts of a basic block
154           * and the others which can be deduced from this basic block
155           * @param bb basic block to start with
156           * @param ec execution count to be added 
157           */
158         virtual int updateExecutionCounts(BPatch_basicBlock* bb,int ec);
159 public:
160         pthread_mutex_t updateLock;
161
162         /** constructor of the class */
163         FunctionCoverage(); 
164
165         /** constructor of the class
166          * @param f function assigned to the object
167          * @param t thread of the mutatee which function belongs
168          * @param i image of the mutatee which function belongs
169          * @param funcN name of the function
170          * @param fileN name of the source file function is in
171          */
172         FunctionCoverage(BPatch_function* f,BPatch_thread* t,BPatch_image* i,
173                          const char* funcN);
174
175         /** method to create control flow graph of the function */
176         int createCFG();
177
178         /** method to set the id of the object
179           * this id is used during on demand instrumentation
180           * to identify which function is just called
181           * @param i identifier for the object
182           */
183         void setId(int i);
184
185         /** method that inserts breakpoint to the beginning of the function
186           * It also inserts an instrumentation code that assigns id of the
187           * function to the variable given as an argument 
188           * @param v variable to assign the function id to
189           */
190         BPatchSnippetHandle* insertBreakPointatEntry(BPatch_variableExpr* v);
191
192         /** method that selects basic blocks to instrument */
193         int selectInstrumentationPoints();
194
195         /** method that inserts instrumentation code to the beginning of the
196           * basic blocks
197           */
198         int instrumentPoints();
199
200         /** method to update the execution counts of the basic blocks
201           * in deletion intervals.
202           */
203         int updateExecutionCounts();
204
205         /** method to update line stuctures */
206         int updateLinesCovered(BPatch_sourceBlock* sb);
207
208         /** method to print coverage results to the given file
209           * @param cf file to print the results to
210           * @param isInst flag whether the function is executed at all or not
211           */
212         int printCoverageInformation(std::ofstream& cf);
213
214         void addSourceFile(FileLineCoverage*);
215
216         /** destructor of the class */
217         virtual ~FunctionCoverage();
218 };
219
220 #endif /* _FunctionCoverage_h_ */