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 }
340