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
47enum 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  };
54typedef enum tahoe_opermodes tahoe_operandenum;
55
56/*
57 * A symbol to be the child of indirect callf:
58 */
59static Sym indirectchild;
60
61static tahoe_operandenum tahoe_operandmode (unsigned char *);
62static char *tahoe_operandname (tahoe_operandenum);
63static long tahoe_operandlength (unsigned char *);
64static bfd_signed_vma tahoe_offset (unsigned char *);
65void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
66
67static tahoe_operandenum
68tahoe_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
108static char *
109tahoe_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
161static long
162tahoe_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
199static bfd_signed_vma
200tahoe_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
219void
220tahoe_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}
340