Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / gprof / tahoe.c
1 /*
2  * Copyright (c) 1983, 1993, 2001
3  *      The Regents of the University of California.  All rights reserved.
4  *
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.
16  *
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.
28  */
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"
36
37     /*
38      *        opcode of the `callf' instruction
39      */
40 #define CALLF   0xfe
41
42     /*
43      *        register for pc relative addressing
44      */
45 #define PC      0xf
46
47 enum tahoe_opermodes
48   {
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
53   };
54 typedef enum tahoe_opermodes tahoe_operandenum;
55
56 /*
57  * A symbol to be the child of indirect callf:
58  */
59 static Sym indirectchild;
60
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);
66
67 static tahoe_operandenum
68 tahoe_operandmode (unsigned char *modep)
69 {
70   long usesreg = *modep & 0xf;
71
72   switch ((*modep >> 4) & 0xf)
73     {
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;
103     }
104   /* NOTREACHED */
105   abort ();
106 }
107
108 static char *
109 tahoe_operandname (tahoe_operandenum mode)
110 {
111
112   switch (mode)
113     {
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";
156     }
157   /* NOTREACHED */
158   abort ();
159 }
160
161 static long
162 tahoe_operandlength (unsigned char *modep
163 )
164 {
165
166   switch (tahoe_operandmode (modep))
167     {
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);
194     }
195   /* NOTREACHED */
196   abort ();
197 }
198
199 static bfd_signed_vma
200 tahoe_offset (unsigned char *modep)
201 {
202   tahoe_operandenum mode = tahoe_operandmode (modep);
203
204   ++modep;                              /* skip over the mode */
205   switch (mode)
206     {
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);
216     }
217 }
218
219 void
220 tahoe_find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
221 {
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;
229
230   if (!inited)
231     {
232       inited = TRUE;
233       sym_init (&indirectchild);
234       indirectchild.cg.prop.fract = 1.0;
235       indirectchild.cg.cyc.head = &indirectchild;
236     }
237
238   DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
239                           parent->name, (unsigned long) p_lowpc,
240                           (unsigned long) p_highpc));
241   for (pc = p_lowpc; pc < p_highpc; pc += length)
242     {
243       length = 1;
244       instructp = ((unsigned char *) core_text_space
245                    + pc - core_text_sect->vma);
246       if ((*instructp & 0xff) == CALLF)
247         {
248           /*
249            *    maybe a callf, better check it out.
250            *      skip the count of the number of arguments.
251            */
252           DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
253                                   (unsigned long) pc));
254           firstmode = tahoe_operandmode (instructp + length);
255           switch (firstmode)
256             {
257             case literal:
258             case immediate:
259               break;
260             default:
261               goto botched;
262             }
263           length += tahoe_operandlength (instructp + length);
264           mode = tahoe_operandmode (instructp + length);
265           DBG (CALLDEBUG,
266                printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
267                printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
268             );
269           switch (mode)
270             {
271             case regdef:
272             case bytedispdef:
273             case worddispdef:
274             case longdispdef:
275             case bytereldef:
276             case wordreldef:
277             case longreldef:
278               /*
279                *    indirect call: call through pointer
280                *      either  *d(r)   as a parameter or local
281                *              (r)     as a return value
282                *              *f      as a global pointer
283                *      [are there others that we miss?,
284                *       e.g. arrays of pointers to functions???]
285                */
286               arc_add (parent, &indirectchild, (unsigned long) 0);
287               length += tahoe_operandlength (instructp + length);
288               continue;
289             case byterel:
290             case wordrel:
291             case longrel:
292               /*
293                *    regular pc relative addressing
294                *      check that this is the address of
295                *      a function.
296                */
297               destpc = pc + tahoe_offset (instructp + length);
298               if (hist_check_address (destpc))
299                 {
300                   child = sym_lookup (&symtab, destpc);
301                   if (child)
302                     {
303                       DBG (CALLDEBUG,
304                            printf ("[findcall]\tdestpc 0x%lx",
305                                    (unsigned long) destpc);
306                            printf (" child->name %s", child->name);
307                            printf (" child->addr 0x%lx\n",
308                                    (unsigned long) child->addr);
309                         );
310                       if (child->addr == destpc)
311                         {
312                           /*
313                            *    a hit
314                            */
315                           arc_add (parent, child, (unsigned long) 0);
316                           length += tahoe_operandlength (instructp + length);
317                           continue;
318                         }
319                     }
320                   goto botched;
321                 }
322               /*
323                *    else:
324                *      it looked like a callf,
325                *      but it wasn't to anywhere.
326                */
327               goto botched;
328             default:
329             botched:
330               /*
331                *    something funny going on.
332                */
333               DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
334               length = 1;
335               continue;
336             }
337         }
338     }
339 }