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