added insn generated metric.
[dyninst.git] / dyninstAPI / src / inst.h
1 /*
2  *  Copyright 1993 Jeff Hollingsworth.  All rights reserved.
3  *
4  */
5
6 /*
7  * inst.h - This file contains the insrumentation functions that are provied
8  *   by the instrumentation layer.
9  *
10  * $Log: inst.h,v $
11  * Revision 1.4  1994/07/20 23:23:38  hollings
12  * added insn generated metric.
13  *
14  * Revision 1.3  1994/07/05  03:26:06  hollings
15  * observed cost model
16  *
17  * Revision 1.2  1994/06/29  02:52:31  hollings
18  * Added metricDefs-common.{C,h}
19  * Added module level performance data
20  * cleanedup types of inferrior addresses instrumentation defintions
21  * added firewalls for large branch displacements due to text+data over 2meg.
22  * assorted bug fixes.
23  *
24  * Revision 1.1  1994/01/27  20:31:25  hollings
25  * Iinital version of paradynd speaking dynRPC igend protocol.
26  *
27  * Revision 1.8  1993/10/19  15:29:19  hollings
28  * AST based mini-tramp code generator.
29  *
30  * Revision 1.7  1993/10/01  21:29:41  hollings
31  * Added resource discovery and filters.
32  *
33  * Revision 1.6  1993/08/20  21:59:49  hollings
34  * changed typedef to have seperate structs to get around gdb bug.
35  *
36  * Revision 1.5  1993/08/11  01:32:24  hollings
37  * added prototypes for predicated cost model.
38  *
39  * Revision 1.4  1993/06/22  19:00:01  hollings
40  * global inst state.
41  *
42  * Revision 1.3  1993/06/08  20:14:34  hollings
43  * state prior to bc net ptrace replacement.
44  *
45  * Revision 1.2  1993/04/27  14:39:21  hollings
46  * signal forwarding and args tramp.
47  *
48  * Revision 1.1  1993/03/19  22:51:05  hollings
49  * Initial revision
50  *
51  *
52  */
53 typedef enum { callNoArgs, callRecordType, callFullArgs } callOptions;
54 typedef enum { callPreInsn, callPostInsn } callWhen;
55 typedef enum { orderFirstAtPoint, orderLastAtPoint } callOrder;
56
57 /* handle to an installed instruementation point */
58 typedef struct instInstanceRec instInstance;    
59
60 struct _intCounterHandle {
61     process *proc;
62     intCounter *counterPtr;             /* NOT in our address space !!!! */
63     intCounter data;                    /* a copy in our address space */
64     instInstance *sampler;              /* function to sample value */
65 };
66
67 typedef struct _intCounterHandle intCounterHandle;
68
69 struct _timerHandle {
70     process *proc;
71     tTimer *timerPtr;                   /* NOT in our address space !!!! */
72     tTimer data;                        /* a copy in our address space !!!! */
73     instInstance *sampler;              /* function to sample value */
74 };
75
76 typedef struct _timerHandle timerHandle;
77
78 class AstNode;
79
80 /*
81  * Insert instrumentation a the specificed codeLocation.
82  *
83  */
84 instInstance *addInstFunc(process *proc, instPoint *location, AstNode *ast, 
85     callWhen when, callOrder order);
86
87 float getPointFrequency(instPoint *point);
88
89 void deleteInst(instInstance*);
90
91 intCounterHandle *createIntCounter(process *proc, int value, Boolean report);
92 int getIntCounterValue(intCounterHandle*);
93 void freeIntCounter(intCounterHandle*);
94 void addToIntCounter(intCounterHandle*, int amount);
95
96 floatCounter *createFloatCounter(int pid);
97 float getCounterValue(floatCounter*);
98 void freeFloatCounter(floatCounter*);
99 void addToFloatCounter(floatCounter*, float amount);
100
101 /*
102  * Create a triggered timer.  A triggered timer is one that only will start/stop
103  *   when the value of the trigger counter is positive.
104  *
105  *   type indicates if the timer is based on wall or process (virtual) time.
106  *
107  *   trigger indicates the trigger counter to use.  A null trigger implies no
108  *     trigger is required.
109  *
110  *   pid is the thread that the timer will run in.
111  */
112 timerHandle *createTimer(process*proc,timerType type, Boolean report);
113
114 /*
115  * return the current value of the timer.
116  *
117  */
118 float getTimerValue(timerHandle *timer);
119
120 /*
121  * dispose of a timer. 
122  *
123  */
124 void freeTimer(timerHandle*);
125
126 /*
127  * Test if the inst point is for a call to a user function (as opposed to
128  *   a library function.
129  *
130  */
131 int callsUserFuncP(instPoint *);
132
133 /* return the function asociated with a point. */
134 function *getFunction(instPoint *point);
135
136 /*
137  * struct to define a list of inst requests 
138  *
139  */
140 #define FUNC_ENTRY      0x1             /* entry to the function */
141 #define FUNC_EXIT       0x2             /* exit from function */
142 #define FUNC_CALL       0x4             /* subroutines called from func */
143 #define FUNC_ARG        0x8             /* use arg as argument */
144
145 class instMaping {
146     public:
147         char *func;         /* function to instrument */
148         char *inst;         /* inst. function to place at func */
149         int where;          /* FUNC_ENTRY, FUNC_EXIT, FUNC_CALL */
150         AstNode *arg;       /* what to pass as arg0 */
151 };
152
153 /*
154  * Install a list of inst requests in a process.
155  *
156  */
157 void installDefaultInst(process *proc, instMaping *initialRequests);
158
159 /*
160  * get information about the cost of pimitives.
161  *
162  */
163 void initPrimitiveCost();
164 void initDefaultPointFrequencyTable();
165
166 //
167 // Return the expected runtime of the passed function in instruction
168 //   times.
169 //
170 int getPrimitiveCost(char *name);
171
172 // a register.
173 typedef int reg;
174
175 typedef enum { plusOp,
176                minusOp,
177                timesOp,
178                divOp,
179                lessOp,
180                leOp,
181                greaterOp,
182                geOp,
183                eqOp,
184                neOp,
185                loadOp,           
186                loadConstOp,
187                storeOp,
188                ifOp,
189                callOp,
190                trampPreamble,
191                trampTrailer,
192                noOp,
193                orOp,
194                andOp} opCode;
195
196 /*
197  * Generate an instruction.
198  *
199  */
200 caddr_t emit(opCode op, reg src1, reg src2, reg dest, char *insn, caddr_t *base);
201
202 /*
203  * get the requested parameter into a register.
204  *
205  */
206 reg getParameter(reg dest, int param);
207
208 #define INFERRIOR_HEAP_BASE     "DYNINSTdata"
209 #define GLOBAL_HEAP_BASE        "DYNINSTglobalData"
210
211 struct _pointRec {
212     instInstance *inst;
213 };
214
215 typedef struct _pointRec pointRec;