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