initial dyninstAPI commit for code coverage
[dyninst.git] / dyninstAPI / src / LineInformation.h
1 #ifndef _LineInformation_h_
2 #define _LineInformation_h_
3
4 #include "common/h/Types.h"
5 #include "common/h/Pair.h"
6 #include "common/h/Vector.h"
7 #include "common/h/Dictionary.h"
8 #include "common/h/String.h"
9 #include "BPatch_Set.h"
10
11 typedef struct tuple {
12         unsigned short lineNo;
13         Address codeAddress;
14         unsigned short linePtr;
15         unsigned short addrPtr;
16
17         tuple(unsigned short l,Address a): lineNo(l),codeAddress(a) {}
18
19 } tuple;
20
21 typedef struct FunctionInfo {
22         bool validInfo;
23         tuple* startLinePtr;
24         tuple* endLinePtr;
25         tuple* startAddrPtr;
26         tuple* endAddrPtr;
27
28         FunctionInfo() : validInfo(false) {}
29 } FunctionInfo;
30
31 //the following class declarations keep the line information for modules.
32
33 /** this class contains array of tuples for mapping from line number to address
34   * and for address to line number. These two arrays are sorted in increasing order
35   * besides keeping the arrays it contains a mapping from function name to FunctionInfo
36   * structure to keep track of the starting and ending points of the information for a 
37   * function. This class represents the line information for a file in a module,
38   * and functions declared in that file.
39   */
40 class FileLineInformation{
41         friend class BPatch_thread;
42         friend class LineInformation;
43         friend ostream& operator<<(ostream&,FileLineInformation&);
44
45         /** structure to keep the mapping from line number to adress
46           * or vice versa
47           */
48 public:
49 private:
50         /** structure to keep the line information for each function in the module
51           */
52
53         /** name of the source file this class represents */
54         string sourceFileName;
55
56         /** number of entries in the mapping array */
57         unsigned short size;
58
59         /** array of tuple structure sorted according to lineNo field */
60         tuple** lineToAddr;
61
62         /** array of tuple structure sorted according to codeAddress field */
63         tuple** addrToLine;
64
65         /** a mapping from function name to the structure FunctionInfo */
66         unsigned short functionCount;
67         string** functionNameList;
68         FunctionInfo** lineInformationList;
69         
70 public:
71         /** constructor
72           * @param fileName name of the source file this object is created */
73         FileLineInformation(string fileName);
74
75
76         string getFileName() { return sourceFileName; }
77
78         /** destructor */
79         ~FileLineInformation();
80
81         /** method that returns function info for a given function 
82           * @param functionName name of the function
83           */
84         FunctionInfo* findFunctionInfo(string functionName);
85
86         /** method that inserts a function entry to the map 
87           * @param functionName function name to insert 
88           */
89         void insertFunction(string functionName);
90
91         /** method that checks the mapping for existence of the function */
92         bool findFunction(string functionName);
93
94         /** method that cleans the record for the given function */
95         void deleteFunction(string functionName);
96
97         /** method that updates the info for a function */
98         bool insertFunction(string functionName,Address beginAddr,
99                             Address functionSize);
100
101         /** method that inserts a line information entry to the array of
102           * tuples and updates the info for function given.
103           * @param functionName name of the function to update info for
104           * @param lineNo line number information
105           * @param codeAddress address corresponding to the line number
106           */
107         void insertLineAddress(string functionName,
108                                unsigned short lineNo,Address codeAddress);
109
110         /** method that finds the line number corresponding to a given
111           * address. In case line number is not found it returns 
112           * false, otherwise true. This function searches in two scopes.
113           * if isFile, then the line number info is searched in file level,
114           * otherwise in function level. If there are more than 1 line info 
115           * for the address then the maximum is taken
116           * @param name name of the function
117           * @param lineNo line number to return
118           * @param codeAddress address given to search
119           * @param isFile flag that defines the scope of search
120           * @param isExactMatch flag defining whether exact match is searched
121           */
122         bool getLineFromAddr(string name,unsigned short& lineNo,
123                              Address codeAddress,bool isFile=false,
124                              bool isExactMatch=true);
125
126         /** as is in previous explanation except set of lines is returned
127           * instead of a single line number */
128         bool getLineFromAddr(string name,BPatch_Set<unsigned short>& lines,
129                              Address codeAddress,bool isFile=false,
130                              bool isExactMatch=true);
131
132         /** method that returns set of addresses for a given line number
133           * the search can be done in file level or in function level 
134           * if the address is found in the map it return true
135           * otherwise it returns false.
136           * @param name name of the function
137           * @param codeAddress address set to return
138           * @param lineNo line number togiven to search 
139           * @param isFile flag that defines the scope of search
140           * @param isExactMatch flag defining whether exact match is searched
141           */
142         bool getAddrFromLine(string name,BPatch_Set<Address>& codeAddress,
143                              unsigned short lineNo,bool isFile=false,
144                              bool isExactMatch=true);
145
146         bool getMinMaxAddress(int n,Address& min,Address& max);
147
148         unsigned short getFunctionCount();
149         string** getFunctionNameList();
150
151         /** tempoprary method to be deleted in commit */
152         void print();
153 };
154
155 /** class which contains a mapping from file names to the line information
156   * object for those file names.
157   */
158 class LineInformation {
159 private:
160         friend class BPatch_thread;
161         friend ostream& operator<<(ostream&,LineInformation&);
162
163         /** name of the module this object belongs to */
164         string moduleName;
165
166         /** mapping from source file name to line info object for that
167           * file. If the module has more than 1 source file than it 
168           * will contain entry for each source file. The file names are
169           * inserted as given by stab info ( it may be full path or only
170           * file name).
171           */
172         unsigned short sourceFileCount;
173         string** sourceFileList;
174         FileLineInformation** lineInformationList;
175
176 public:
177
178         /** constructor 
179           * @param mName module name
180           */
181         LineInformation(string mName) ;
182         
183         /** destructor */
184         ~LineInformation(); 
185
186         /** method to insert an entry to the line info for a file.
187           * inserts an entry to the mapping from file name to line
188           * info object for the given function. The latest one always replaces the
189           * previous ones.
190           * @param functionName function name to insert
191           * @param fileName file name which the function belongs */
192         void insertSourceFileName(string functionName,string fileName);
193
194         /** method that inserts a line information entry to corresponding
195           * file line information object for the given file name and
196           * function.
197           * @param functionName name of the function
198           * @param fileName name of the source file function belongs
199           * @param lineNo line number information
200           * @param codeAddress address corresponding to the line number
201           */
202         void insertLineAddress(string functionName,string fileName,
203                                unsigned short lineNo,Address codeAddress);
204
205         /** method that finds the line number corresponding to a given
206           * address. In case line number is not found it returns 
207           * false, otherwise true. This function searches in two scopes.
208           * if isFile, then the line number info is searched in file level,
209           * otherwise in function level. If there are more than 1 line info 
210           * for the address then the maximum is taken
211           * @param name name of the function/file
212           * @param lineNo line number to return
213           * @param codeAddress address given to search
214           * @param isFile flag that defines the scope of search
215           * @param isExactMatch flag defining whether exact match is searched
216           */
217         bool getLineFromAddr(string name,unsigned short& lineNo,
218                              Address codeAddress,bool isFile=false,
219                              bool isExactMatch=true);
220
221         /** the same as previous except it returns all corresponding 
222           * lines for the given address */
223         bool getLineFromAddr(string name,BPatch_Set<unsigned short>& lines,
224                              Address codeAddress,bool isFile=false,
225                              bool isExactMatch=true);
226
227         /** method that returns set of addresses for a given line number
228           * the search can be done in file level or in function level 
229           * if the address is found in the map it return true
230           * otherwise it returns false.
231           * @param name name of the function or file
232           * @param codeAddress address set to return
233           * @param lineNo line number togiven to search 
234           * @param isFile flag that defines the scope of search
235           * @param isExactMatch flag defining whether exact match is searched
236           */
237         bool getAddrFromLine(string name,BPatch_Set<Address>& codeAddress,
238                              unsigned short lineNo,bool isFile=false,
239                              bool isExactMatch=true);
240
241         /** method that returns set of addresses corresponding to a line number
242           * for the file which is name of the module
243           * In failure it returns false
244           */
245         bool getAddrFromLine(BPatch_Set<Address>& codeAddress,unsigned short lineNo,
246                              bool isExactMatch=true);
247
248         /** method that returns the line info object for a given file name 
249           * It returns NULL if the entry does not exist.
250           * @param fileName name of the source file
251           */
252         FileLineInformation* getFileLineInformation(string fileName);
253
254         /** method that returns the line info object for the file 
255           * for a given function name
256           * @param functionName name of the function being looked for
257           */
258         FileLineInformation* getFunctionLineInformation(string functionName);
259
260         /** method that checks the existence of a function in the line info object */
261         bool findFunction(string functionName);
262
263         /** method that cleans the record for the given function */
264         void deleteFunction(string functionName);
265
266         /** method that updates the info for a function */
267         void insertFunction(string functionName,Address beginAddr,
268                             Address functionSize);
269                              
270
271         string** getSourceFileList();
272         unsigned short getSourceFileCount();
273         FileLineInformation** getLineInformationList();
274
275         /** tempoprary method to be deleted in commit */
276         void print();
277 };
278
279 #ifdef rs6000_ibm_aix4_1
280 // This is only used in BPatch_module.C; the only reason it needs to be in a
281 // header file is so that BPatch_templates.C can include it to instantiate
282 // BPatch_Vector<IncludeFileInfo>.
283 class IncludeFileInfo {
284 public:
285         unsigned int begin;
286         unsigned int end;
287         string       name;
288
289         IncludeFileInfo() : begin(0), end(0) {};
290         IncludeFileInfo(int _begin, const char *_name) :
291                 begin(_begin), end(0), name(_name) {};
292 };
293 #endif
294
295 #endif /*_LineInformation_h_*/