bfd/
[binutils.git] / gprof / vax.c
blob6216589d96059faad3cb9e2be24c0738f680cbe9
1 /*
2 * Copyright (c) 1983, 1993, 2001
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
29 #include "gprof.h"
30 #include "search_list.h"
31 #include "source.h"
32 #include "symtab.h"
33 #include "cg_arcs.h"
34 #include "corefile.h"
35 #include "hist.h"
38 * opcode of the `calls' instruction
40 #define CALLS 0xfb
43 * register for pc relative addressing
45 #define PC 0xf
47 enum opermodes
49 literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
50 bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
51 immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
52 longrel, longreldef
54 typedef enum opermodes operandenum;
56 /* *INDENT-OFF* */
57 /* Here to document only. We can't use this when cross compiling as
58 the bitfield layout might not be the same as native.
60 struct modebyte
62 unsigned int regfield:4;
63 unsigned int modefield:4;
66 /* *INDENT-ON* */
69 * A symbol to be the child of indirect calls:
71 static Sym indirectchild;
73 static operandenum vax_operandmode (unsigned char *);
74 static char *vax_operandname (operandenum);
75 static long vax_operandlength (unsigned char *);
76 static bfd_signed_vma vax_offset (unsigned char *);
77 void vax_find_call (Sym *, bfd_vma, bfd_vma);
79 static operandenum
80 vax_operandmode (unsigned char *modep)
82 int usesreg = *modep & 0xf;
84 switch ((*modep >> 4) & 0xf)
86 case 0:
87 case 1:
88 case 2:
89 case 3:
90 return literal;
91 case 4:
92 return indexed;
93 case 5:
94 return reg;
95 case 6:
96 return regdef;
97 case 7:
98 return autodec;
99 case 8:
100 return usesreg != PC ? autoinc : immediate;
101 case 9:
102 return usesreg != PC ? autoincdef : absolute;
103 case 10:
104 return usesreg != PC ? bytedisp : byterel;
105 case 11:
106 return usesreg != PC ? bytedispdef : bytereldef;
107 case 12:
108 return usesreg != PC ? worddisp : wordrel;
109 case 13:
110 return usesreg != PC ? worddispdef : wordreldef;
111 case 14:
112 return usesreg != PC ? longdisp : longrel;
113 case 15:
114 return usesreg != PC ? longdispdef : longreldef;
116 /* NOTREACHED */
117 abort ();
120 static char *
121 vax_operandname (operandenum mode)
124 switch (mode)
126 case literal:
127 return "literal";
128 case indexed:
129 return "indexed";
130 case reg:
131 return "register";
132 case regdef:
133 return "register deferred";
134 case autodec:
135 return "autodecrement";
136 case autoinc:
137 return "autoincrement";
138 case autoincdef:
139 return "autoincrement deferred";
140 case bytedisp:
141 return "byte displacement";
142 case bytedispdef:
143 return "byte displacement deferred";
144 case byterel:
145 return "byte relative";
146 case bytereldef:
147 return "byte relative deferred";
148 case worddisp:
149 return "word displacement";
150 case worddispdef:
151 return "word displacement deferred";
152 case wordrel:
153 return "word relative";
154 case wordreldef:
155 return "word relative deferred";
156 case immediate:
157 return "immediate";
158 case absolute:
159 return "absolute";
160 case longdisp:
161 return "long displacement";
162 case longdispdef:
163 return "long displacement deferred";
164 case longrel:
165 return "long relative";
166 case longreldef:
167 return "long relative deferred";
169 /* NOTREACHED */
170 abort ();
173 static long
174 vax_operandlength (unsigned char *modep)
177 switch (vax_operandmode (modep))
179 case literal:
180 case reg:
181 case regdef:
182 case autodec:
183 case autoinc:
184 case autoincdef:
185 return 1;
186 case bytedisp:
187 case bytedispdef:
188 case byterel:
189 case bytereldef:
190 return 2;
191 case worddisp:
192 case worddispdef:
193 case wordrel:
194 case wordreldef:
195 return 3;
196 case immediate:
197 case absolute:
198 case longdisp:
199 case longdispdef:
200 case longrel:
201 case longreldef:
202 return 5;
203 case indexed:
204 return 1 + vax_operandlength (modep + 1);
206 /* NOTREACHED */
207 abort ();
210 static bfd_signed_vma
211 vax_offset (unsigned char *modep)
213 operandenum mode = vax_operandmode (modep);
215 ++modep; /* skip over the mode */
216 switch (mode)
218 default:
219 fprintf (stderr, "[reladdr] not relative address\n");
220 return 0;
221 case byterel:
222 return 1 + bfd_get_signed_8 (core_bfd, modep);
223 case wordrel:
224 return 2 + bfd_get_signed_16 (core_bfd, modep);
225 case longrel:
226 return 4 + bfd_get_signed_32 (core_bfd, modep);
231 void
232 vax_find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
234 unsigned char *instructp;
235 long length;
236 Sym *child;
237 operandenum mode;
238 operandenum firstmode;
239 bfd_vma pc, destpc;
240 static bfd_boolean inited = FALSE;
242 if (!inited)
244 inited = TRUE;
245 sym_init (&indirectchild);
246 indirectchild.cg.prop.fract = 1.0;
247 indirectchild.cg.cyc.head = &indirectchild;
250 if (core_text_space == 0)
252 return;
254 if (p_lowpc < s_lowpc)
256 p_lowpc = s_lowpc;
258 if (p_highpc > s_highpc)
260 p_highpc = s_highpc;
262 DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
263 parent->name, (unsigned long) p_lowpc,
264 (unsigned long) p_highpc));
265 for (pc = p_lowpc; pc < p_highpc; pc += length)
267 length = 1;
268 instructp = ((unsigned char *) core_text_space
269 + pc - core_text_sect->vma);
270 if ((*instructp & 0xff) == CALLS)
273 * maybe a calls, better check it out.
274 * skip the count of the number of arguments.
276 DBG (CALLDEBUG,
277 printf ("[findcall]\t0x%lx:calls", (unsigned long) pc));
278 firstmode = vax_operandmode (instructp + length);
279 switch (firstmode)
281 case literal:
282 case immediate:
283 break;
284 default:
285 goto botched;
287 length += vax_operandlength (instructp + length);
288 mode = vax_operandmode (instructp + length);
289 DBG (CALLDEBUG,
290 printf ("\tfirst operand is %s", vax_operandname (firstmode));
291 printf ("\tsecond operand is %s\n", vax_operandname (mode)));
292 switch (mode)
294 case regdef:
295 case bytedispdef:
296 case worddispdef:
297 case longdispdef:
298 case bytereldef:
299 case wordreldef:
300 case longreldef:
302 * indirect call: call through pointer
303 * either *d(r) as a parameter or local
304 * (r) as a return value
305 * *f as a global pointer
306 * [are there others that we miss?,
307 * e.g. arrays of pointers to functions???]
309 arc_add (parent, &indirectchild, (unsigned long) 0);
310 length += vax_operandlength (instructp + length);
311 continue;
312 case byterel:
313 case wordrel:
314 case longrel:
316 * regular pc relative addressing
317 * check that this is the address of
318 * a function.
320 destpc = pc + vax_offset (instructp + length);
321 if (destpc >= s_lowpc && destpc <= s_highpc)
323 child = sym_lookup (&symtab, destpc);
324 DBG (CALLDEBUG,
325 printf ("[findcall]\tdestpc 0x%lx",
326 (unsigned long) destpc);
327 printf (" child->name %s", child->name);
328 printf (" child->addr 0x%lx\n",
329 (unsigned long) child->addr);
331 if (child->addr == destpc)
334 * a hit
336 arc_add (parent, child, (unsigned long) 0);
337 length += vax_operandlength (instructp + length);
338 continue;
340 goto botched;
343 * else:
344 * it looked like a calls,
345 * but it wasn't to anywhere.
347 goto botched;
348 default:
349 botched:
351 * something funny going on.
353 DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
354 length = 1;
355 continue;