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