Made structs classes
[dyninst.git] / dyninstAPI / src / symtab.h
1 /*
2  *  Copyright 1993 Jeff Hollingsworth.  All rights reserved.
3  *
4  */
5
6 /*
7  * symtab.h - interface to generic symbol table.
8  *
9  * $Log: symtab.h,v $
10  * Revision 1.6  1994/09/22 02:26:56  markc
11  * Made structs classes
12  *
13  * Revision 1.5  1994/08/02  18:25:08  hollings
14  * fixed modules to use list template for lists of functions.
15  *
16  * Revision 1.4  1994/07/22  19:21:11  hollings
17  * removed mistaken divid by 1Meg for predicted cost.
18  *
19  * Revision 1.3  1994/07/20  23:23:43  hollings
20  * added insn generated metric.
21  *
22  * Revision 1.2  1994/06/29  02:52:52  hollings
23  * Added metricDefs-common.{C,h}
24  * Added module level performance data
25  * cleanedup types of inferrior addresses instrumentation defintions
26  * added firewalls for large branch displacements due to text+data over 2meg.
27  * assorted bug fixes.
28  *
29  * Revision 1.1  1994/01/27  20:31:46  hollings
30  * Iinital version of paradynd speaking dynRPC igend protocol.
31  *
32  * Revision 1.4  1993/12/13  19:58:12  hollings
33  * added sibling filed for functions that occur multiple times in the same
34  * binary image (statics, and c++ template classes for example).
35  *
36  * Revision 1.3  1993/07/13  18:33:11  hollings
37  * new include file syntax.
38  *
39  * Revision 1.2  1993/06/08  20:14:34  hollings
40  * state prior to bc net ptrace replacement.
41  *
42  * Revision 1.1  1993/03/19  22:51:05  hollings
43  * Initial revision
44  *
45  *
46  */
47
48 extern "C" {
49 #include <sys/types.h>
50 #include <stdlib.h>
51 }
52
53 #include "util/h/stringPool.h"
54 #include "util/h/list.h"
55 #include "dyninst.h"
56 #include "arch-sparc.h"
57 #include "util.h"
58
59 /*
60  * List of supported languages.
61  *
62  */
63 typedef enum { unknown, assembly, C, cPlusPlus, gnuCPlusPlus,
64     fortran, CMFortran } supportedLanguages;
65
66 #define LIBRARY_MODULE  "LIBRARY_MODULE"
67 #define NO_SYMS_MODULE  "NO_SYMS_MODULE"
68
69 class pdFunction;
70 class instPoint;
71 class module;
72 class image;
73 class internalSym;
74
75 class pdFunction {
76  public:
77     pdFunction();
78     stringHandle symTabName;            /* name as it appears in the symbol table */
79     stringHandle prettyName;            /* user's view of name (i.e. de-mangled) */
80     int line;                   /* first line of function */
81     module *file;               /* pointer to file that defines func. */
82     caddr_t addr;               /* address of the start of the func */
83     instPoint *funcEntry;       /* place to instrument entry (often not addr) */
84     instPoint *funcReturn;      /* exit point for function */
85     int callLimit;              /* max val of calls array */
86     int callCount;              /* number of sub-routine cal points */
87     instPoint **calls;          /* pointer to the calls */
88     int ljmpCount;              /* number of long jumps out of func */
89     instPoint *jmps;            /* long jumps out */
90     int tag;                    /* tags to ident special (library) funcs. */
91     pdFunction *next;           /* next function in global function list */
92     pdFunction *sibling;                /* next function with the same name - WARNING
93                                         we assume name equality so this
94                                         could either be c++ template functions
95                                         beging replicated or other non global
96                                         functions that appear twice.
97                                 */
98 };
99
100
101 class instPoint {
102  public:
103     instPoint() {
104       addr = 0; originalInstruction.raw = 0; delaySlotInsn.raw = 0;
105       aggregateInsn.raw =0;
106       inDelaySlot=0; isDelayed = 0; callIndirect=0; callAggregate=0;
107       callee=NULL; func=NULL;
108     }
109     int addr;                   /* address of inst point */
110     instruction originalInstruction;    /* original instruction */
111     instruction delaySlotInsn;  /* original instruction */
112     instruction aggregateInsn;  /* aggregate insn */
113     int inDelaySlot;            /* Is the instruction in a dealy slot */
114     int isDelayed;              /* is the instruction a delayed instruction */
115     int callIndirect;           /* is it a call whose target is rt computed ? */
116     int callAggregate;          /* calling a func that returns an aggregate
117                                    we need to reolcate three insns in this case
118                                  */
119     pdFunction *callee;         /* what function is called */
120     pdFunction *func;           /* what function we are inst */
121 };
122
123
124 /* Stores source code to address in text association for modules */
125 class lineTable {
126  public:
127     lineTable() {
128       maxLine = 100;
129       addr = (caddr_t *) xcalloc(100, sizeof(caddr_t));
130     }
131     ~lineTable() {
132       if (addr)
133         free(addr);
134     }
135     void qsortLines() {
136       qsort(addr, maxLine, sizeof(int), intComp);
137     }
138     int getMaxLine() { return maxLine;}
139     void setLineAddr (int line, caddr_t lineAddr);
140     caddr_t getLineAddr (int line) {
141       if ((line >= 0) && (line < maxLine))
142         return (addr[line]);
143       else
144         return (NULL);
145     }
146
147   private:
148     int maxLine;                /* max possible line */
149     caddr_t *addr;              /* addr[line] is the addr of line */
150 };
151
152 class module {
153  public:
154     module();
155     void setLineAddr(int line, caddr_t addr) {
156       lines.setLineAddr(line, addr);
157     }
158     caddr_t getLineAddr(int line) {
159       return (lines.getLineAddr(line));
160     }
161     char *compileInfo;
162     stringHandle fileName;              /* short file */
163     stringHandle fullName;              /* full path to file */
164     supportedLanguages language;
165     caddr_t addr;               /* starting address of module */
166     List<pdFunction*> funcs;    /* functions defined in this module */
167     image *exec;                /* what executable it came from */
168     lineTable lines;            /* line mapping info */
169     module *next;               /* pointer to next module */
170 };
171
172 /* contents of line number field if line is unknown */
173 #define UNKNOWN_LINE    0
174
175 #define TAG_LIB_FUNC    0x01
176 #define TAG_IO_FUNC     0x02
177 #define TAG_MSG_FUNC    0x04
178 #define TAG_SYNC_FUNC   0x08
179 #define TAG_CPU_STATE   0x10    /* does the func block waiting for ext. event */
180
181 /*
182  * symbols we need to find from our RTinst library.  This is how we know
183  *   were our inst primatives got loaded as well as the data space variables
184  *   we use to put counters/timers and inst trampolines.  An array of these
185  *   is placed in the image structure.
186  *
187  */
188 class internalSym {
189  public:
190     internalSym() { 
191       name = NULL; addr=0;
192     }
193     stringHandle name;          /* name as it appears in the symbol table. */
194     unsigned int addr;          /* absolute address of the symbol */
195 };
196
197 class image {
198  public:
199     image();
200     stringHandle file;          /* image file name */
201     stringHandle name;          /* filename part of file */
202     int moduleCount;            /* number of modules */
203     module *modules;            /* pointer to modules */
204     int funcCount;              /* number of functions */
205     pdFunction *funcs;          /* pointer to linked list of functions */
206     int iSymCount;              /* # of internal RTinst library symbols */
207     internalSym *iSyms;         /* internal RTinst library symbols */
208     void *code;                 /* pointer to code */
209     unsigned int textOffset;    /* base of where code is loaded */
210     int offset;                 /* offset of a.out in file */
211     HTable<pdFunction*> funcAddrHash; /* hash table to find functions by address */
212     image *next;                /* next in our list of images */
213 };
214
215
216 /*
217  * a definition of a library function that we may wish to identify.  This is
218  *   how we describe it to the symbol table parser, not how it appears in
219  *   the symbol table.  Library functions are placed in a pseudo module 
220  *   named LIBRARY_MODULE. 
221  *
222  */
223 image *parseImage(char *file, int offset);
224 module *newModule(image*, const char *currDir, const char *name, caddr_t addr);
225 pdFunction *newFunc(image*, module *, const char *name, int addr);
226 extern stringPool pool;
227
228 class libraryFunc {
229     public:
230         libraryFunc(const char *n, int t) {
231             name = pool.findAndAdd(n);
232             tags = t;
233         }
234         stringHandle name;
235         int tags;
236 };
237
238 /*
239  * Functions provided by machine/os/vendor specific files.
240  *
241  * iSym is the prefix to match on to find the callable inst functions.
242  *
243  */
244 /*
245 image *loadSymTable(const char *file, int offset, List<libraryFunc*> libraryFunctions, 
246                     const char **iSym);
247 */
248 Boolean locateAllInstPoints(image *i);
249
250 /*
251  * main interface to the symbol table based code.
252  *
253  */
254 image *parseImage(char *file, int offset);
255
256 /*
257  * symbol table access functions.
258  *
259  */
260
261 /* find the named internal symbol */
262 internalSym *findInternalSymbol(image *, const char *name, Boolean warn = True);
263
264 /* find the address of the named internal symbol */
265 caddr_t findInternalAddress(image *, const char *name, Boolean warn = True);
266
267 /* find the named module */
268 module *findModule(image *, const char *name);
269
270 /* find the named funcation */
271 pdFunction *findFunction(image *, const char *name);
272
273 /* find the function add the passed addr */
274 pdFunction *findFunctionByAddr(image *, caddr_t addr);
275
276 /* look through func for inst points */
277 void locateInstPoints(pdFunction*, void *, int, int calls);
278
279 /* record line # for each func entry */
280 void mapLines(module *);