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