merge from gcc
[binutils.git] / gprof / tahoe.c
blobde94db6938af3cc18a14d22f865cfb6cef376f47
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 `callf' instruction
40 #define CALLF 0xfe
43 * register for pc relative addressing
45 #define PC 0xf
47 enum tahoe_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 tahoe_opermodes tahoe_operandenum;
57 * A symbol to be the child of indirect callf:
59 static Sym indirectchild;
61 static tahoe_operandenum tahoe_operandmode (unsigned char *);
62 static char *tahoe_operandname (tahoe_operandenum);
63 static long tahoe_operandlength (unsigned char *);
64 static bfd_signed_vma tahoe_offset (unsigned char *);
65 void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
67 static tahoe_operandenum
68 tahoe_operandmode (unsigned char *modep)
70 long usesreg = *modep & 0xf;
72 switch ((*modep >> 4) & 0xf)
74 case 0:
75 case 1:
76 case 2:
77 case 3:
78 return literal;
79 case 4:
80 return indexed;
81 case 5:
82 return reg;
83 case 6:
84 return regdef;
85 case 7:
86 return autodec;
87 case 8:
88 return usesreg != 0xe ? autoinc : immediate;
89 case 9:
90 return usesreg != PC ? autoincdef : absolute;
91 case 10:
92 return usesreg != PC ? bytedisp : byterel;
93 case 11:
94 return usesreg != PC ? bytedispdef : bytereldef;
95 case 12:
96 return usesreg != PC ? worddisp : wordrel;
97 case 13:
98 return usesreg != PC ? worddispdef : wordreldef;
99 case 14:
100 return usesreg != PC ? longdisp : longrel;
101 case 15:
102 return usesreg != PC ? longdispdef : longreldef;
104 /* NOTREACHED */
105 abort ();
108 static char *
109 tahoe_operandname (tahoe_operandenum mode)
112 switch (mode)
114 case literal:
115 return "literal";
116 case indexed:
117 return "indexed";
118 case reg:
119 return "register";
120 case regdef:
121 return "register deferred";
122 case autodec:
123 return "autodecrement";
124 case autoinc:
125 return "autoincrement";
126 case autoincdef:
127 return "autoincrement deferred";
128 case bytedisp:
129 return "byte displacement";
130 case bytedispdef:
131 return "byte displacement deferred";
132 case byterel:
133 return "byte relative";
134 case bytereldef:
135 return "byte relative deferred";
136 case worddisp:
137 return "word displacement";
138 case worddispdef:
139 return "word displacement deferred";
140 case wordrel:
141 return "word relative";
142 case wordreldef:
143 return "word relative deferred";
144 case immediate:
145 return "immediate";
146 case absolute:
147 return "absolute";
148 case longdisp:
149 return "long displacement";
150 case longdispdef:
151 return "long displacement deferred";
152 case longrel:
153 return "long relative";
154 case longreldef:
155 return "long relative deferred";
157 /* NOTREACHED */
158 abort ();
161 static long
162 tahoe_operandlength (unsigned char *modep
166 switch (tahoe_operandmode (modep))
168 case literal:
169 case reg:
170 case regdef:
171 case autodec:
172 case autoinc:
173 case autoincdef:
174 return 1;
175 case bytedisp:
176 case bytedispdef:
177 case byterel:
178 case bytereldef:
179 return 2;
180 case worddisp:
181 case worddispdef:
182 case wordrel:
183 case wordreldef:
184 return 3;
185 case immediate:
186 case absolute:
187 case longdisp:
188 case longdispdef:
189 case longrel:
190 case longreldef:
191 return 5;
192 case indexed:
193 return 1 + tahoe_operandlength (modep + 1);
195 /* NOTREACHED */
196 abort ();
199 static bfd_signed_vma
200 tahoe_offset (unsigned char *modep)
202 tahoe_operandenum mode = tahoe_operandmode (modep);
204 ++modep; /* skip over the mode */
205 switch (mode)
207 default:
208 fprintf (stderr, "[reladdr] not relative address\n");
209 return 0;
210 case byterel:
211 return 1 + bfd_get_signed_8 (core_bfd, modep);
212 case wordrel:
213 return 2 + bfd_get_signed_16 (core_bfd, modep);
214 case longrel:
215 return 4 + bfd_get_signed_32 (core_bfd, modep);
219 void
220 tahoe_find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
222 unsigned char *instructp;
223 long length;
224 Sym *child;
225 tahoe_operandenum mode;
226 tahoe_operandenum firstmode;
227 bfd_vma pc, destpc;
228 static bfd_boolean inited = FALSE;
230 if (!inited)
232 inited = TRUE;
233 sym_init (&indirectchild);
234 indirectchild.cg.prop.fract = 1.0;
235 indirectchild.cg.cyc.head = &indirectchild;
238 if (core_text_space == 0)
240 return;
242 if (p_lowpc < s_lowpc)
244 p_lowpc = s_lowpc;
246 if (p_highpc > s_highpc)
248 p_highpc = s_highpc;
250 DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
251 parent->name, (unsigned long) p_lowpc,
252 (unsigned long) p_highpc));
253 for (pc = p_lowpc; pc < p_highpc; pc += length)
255 length = 1;
256 instructp = ((unsigned char *) core_text_space
257 + pc - core_text_sect->vma);
258 if ((*instructp & 0xff) == CALLF)
261 * maybe a callf, better check it out.
262 * skip the count of the number of arguments.
264 DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
265 (unsigned long) pc));
266 firstmode = tahoe_operandmode (instructp + length);
267 switch (firstmode)
269 case literal:
270 case immediate:
271 break;
272 default:
273 goto botched;
275 length += tahoe_operandlength (instructp + length);
276 mode = tahoe_operandmode (instructp + length);
277 DBG (CALLDEBUG,
278 printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
279 printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
281 switch (mode)
283 case regdef:
284 case bytedispdef:
285 case worddispdef:
286 case longdispdef:
287 case bytereldef:
288 case wordreldef:
289 case longreldef:
291 * indirect call: call through pointer
292 * either *d(r) as a parameter or local
293 * (r) as a return value
294 * *f as a global pointer
295 * [are there others that we miss?,
296 * e.g. arrays of pointers to functions???]
298 arc_add (parent, &indirectchild, (unsigned long) 0);
299 length += tahoe_operandlength (instructp + length);
300 continue;
301 case byterel:
302 case wordrel:
303 case longrel:
305 * regular pc relative addressing
306 * check that this is the address of
307 * a function.
309 destpc = pc + tahoe_offset (instructp + length);
310 if (destpc >= s_lowpc && destpc <= s_highpc)
312 child = sym_lookup (&symtab, destpc);
313 DBG (CALLDEBUG,
314 printf ("[findcall]\tdestpc 0x%lx",
315 (unsigned long) destpc);
316 printf (" child->name %s", child->name);
317 printf (" child->addr 0x%lx\n",
318 (unsigned long) child->addr);
320 if (child->addr == destpc)
323 * a hit
325 arc_add (parent, child, (unsigned long) 0);
326 length += tahoe_operandlength (instructp + length);
327 continue;
329 goto botched;
332 * else:
333 * it looked like a callf,
334 * but it wasn't to anywhere.
336 goto botched;
337 default:
338 botched:
340 * something funny going on.
342 DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
343 length = 1;
344 continue;