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