fixed modules to use list template for lists of functions.
[dyninst.git] / paradynd / 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.5  1994/08/02 18:25:08  hollings
11  * fixed modules to use list template for lists of functions.
12  *
13  * Revision 1.4  1994/07/22  19:21:11  hollings
14  * removed mistaken divid by 1Meg for predicted cost.
15  *
16  * Revision 1.3  1994/07/20  23:23:43  hollings
17  * added insn generated metric.
18  *
19  * Revision 1.2  1994/06/29  02:52:52  hollings
20  * Added metricDefs-common.{C,h}
21  * Added module level performance data
22  * cleanedup types of inferrior addresses instrumentation defintions
23  * added firewalls for large branch displacements due to text+data over 2meg.
24  * assorted bug fixes.
25  *
26  * Revision 1.1  1994/01/27  20:31:46  hollings
27  * Iinital version of paradynd speaking dynRPC igend protocol.
28  *
29  * Revision 1.4  1993/12/13  19:58:12  hollings
30  * added sibling filed for functions that occur multiple times in the same
31  * binary image (statics, and c++ template classes for example).
32  *
33  * Revision 1.3  1993/07/13  18:33:11  hollings
34  * new include file syntax.
35  *
36  * Revision 1.2  1993/06/08  20:14:34  hollings
37  * state prior to bc net ptrace replacement.
38  *
39  * Revision 1.1  1993/03/19  22:51:05  hollings
40  * Initial revision
41  *
42  *
43  */
44 #include <sys/types.h>
45
46 #include "util/h/stringPool.h"
47 #include "util/h/list.h"
48 #include "dyninst.h"
49
50 /*
51  * List of supported languages.
52  *
53  */
54 typedef enum { unknown, assembly, C, cPlusPlus, gnuCPlusPlus,
55     fortran, CMFortran } supportedLanguages;
56
57 typedef struct functionRec function;
58 typedef struct moduleRec module;
59 typedef struct instPointRec instPoint;
60 typedef struct imageRec image;
61
62 #define LIBRARY_MODULE  "LIBRARY_MODULE"
63 #define NO_SYMS_MODULE  "NO_SYMS_MODULE"
64
65 typedef struct {
66     int maxLine;                /* max possible line */
67     caddr_t *addr;              /* addr[line] is the addr of line */
68 } lineTable;
69
70 struct moduleRec {
71     char *compileInfo;
72     char *fileName;             /* short file */
73     char *fullName;             /* full path to file */
74     supportedLanguages language;
75     caddr_t addr;               /* starting address of module */
76     List<function*> funcs;      /* functions defined in this module */
77     image *exec;                /* what executable it came from */
78     lineTable lines;            /* line mapping info */
79     module *next;               /* pointer to next module */
80 };
81
82 /* contents of line number field if line is unknown */
83 #define UNKNOWN_LINE    0
84
85 #define TAG_LIB_FUNC    0x01
86 #define TAG_IO_FUNC     0x02
87 #define TAG_MSG_FUNC    0x04
88 #define TAG_SYNC_FUNC   0x08
89 #define TAG_CPU_STATE   0x10    /* does the func block waiting for ext. event */
90
91 struct functionRec {
92     char *symTabName;           /* name as it appears in the symbol table */
93     char *prettyName;           /* user's view of name (i.e. de-mangled) */
94     int line;                   /* first line of function */
95     module *file;               /* pointer to file that defines func. */
96     caddr_t addr;               /* address of the start of the func */
97     instPoint *funcEntry;       /* place to instrument entry (often not addr) */
98     instPoint *funcReturn;      /* exit point for function */
99     int callLimit;              /* max val of calls array */
100     int callCount;              /* number of sub-routine cal points */
101     instPoint **calls;          /* pointer to the calls */
102     int ljmpCount;              /* number of long jumps out of func */
103     instPoint *jmps;            /* long jumps out */
104     int tag;                    /* tags to ident special (library) funcs. */
105     function *next;             /* next function in global function list */
106     function *sibling;          /* next function with the same name - WARNING
107                                         we assume name equality so this
108                                         could either be c++ template functions
109                                         beging replicated or other non global
110                                         functions that appear twice.
111                                 */
112 };
113
114 /*
115  * symbols we need to find from our RTinst library.  This is how we know
116  *   were our inst primatives got loaded as well as the data space variables
117  *   we use to put counters/timers and inst trampolines.  An array of these
118  *   is placed in the image structure.
119  *
120  */
121 struct _internalSym {
122     char *name;                 /* name as it appears in the symbol table. */
123     unsigned int addr;          /* absolute address of the symbol */
124 };
125
126 typedef _internalSym internalSym;
127
128 struct imageRec {
129     char *file;                 /* image file name */
130     char *name;                 /* filename part of file */
131     int moduleCount;            /* number of modules */
132     module *modules;            /* pointer to modules */
133     int funcCount;              /* number of functions */
134     function *funcs;            /* pointer to linked list of functions */
135     int iSymCount;              /* # of internal RTinst library symbols */
136     internalSym *iSyms;         /* internal RTinst library symbols */
137     void *code;                 /* pointer to code */
138     unsigned int textOffset;    /* base of where code is loaded */
139     int offset;                 /* offset of a.out in file */
140     HTable<function*> funcAddrHash; /* hash table to find functions by address */
141     image *next;                /* next in our list of images */
142 };
143
144 /*
145  * a definition of a library function that we may wish to identify.  This is
146  *   how we describe it to the symbol table parser, not how it appears in
147  *   the symbol table.  Library functions are placed in a pseudo module 
148  *   named LIBRARY_MODULE. 
149  *
150  */
151 image *parseImage(char *file, int offset);
152 module *newModule(image*, char *currDir, char *name, caddr_t addr);
153 function *newFunc(image*, module *, char *name, int addr);
154 extern stringPool pool;
155
156 class libraryFunc {
157     public:
158         libraryFunc(char *n, int t) {
159             name = pool.findAndAdd(n);
160             tags = t;
161         }
162         char *name;
163         int tags;
164 };
165
166 typedef List<libraryFunc*> libraryList;
167
168 /*
169  * Functions provided by machine/os/vendor specific files.
170  *
171  * iSym is the prefix to match on to find the callable inst functions.
172  *
173  */
174 image *loadSymTable(char *file, int offset, libraryList libraryFunctions, 
175     char **iSym);
176
177 Boolean locateAllInstPoints(image *i);
178
179 /*
180  * main interface to the symbol table based code.
181  *
182  */
183 image *parseImage(char *file, int offset);
184
185 /*
186  * symbol table access functions.
187  *
188  */
189
190 /* find the named internal symbol */
191 internalSym *findInternalSymbol(image *, char *name, Boolean warn = True);
192
193 /* find the address of the named internal symbol */
194 caddr_t findInternalAddress(image *, char *name, Boolean warn = True);
195
196 /* find the named module */
197 module *findModule(image *, char *name);
198
199 /* find the named funcation */
200 function *findFunction(image *, char *name);
201
202 /* find the function add the passed addr */
203 function *findFunctionByAddr(image *, caddr_t addr);
204
205 /* look through func for inst points */
206 void locateInstPoints(function*, void *, int, int calls);
207
208 /*
209  * upcalls from machine specific code to main symbol table package 
210  *
211  */
212 void processLine(module*, int line, caddr_t addr);
213
214 /* record line # for each func entry */
215 void mapLines(module *);