[thirdparty/binutils-gdb.git] / gprof / tahoe.c

/*
 * Copyright (c) 1983, 2001 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that: (1) source distributions retain this entire copyright
 * notice and comment, and (2) distributions including binaries display
 * the following acknowledgement:  ``This product includes software
 * developed by the University of California, Berkeley and its contributors''
 * in the documentation or other materials provided with the distribution
 * and in all advertising materials mentioning features or use of this
 * software. Neither the name of the University nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "cg_arcs.h"
#include "corefile.h"
#include "hist.h"

    /*
     *        opcode of the `callf' instruction
     */
#define	CALLF	0xfe

    /*
     *        register for pc relative addressing
     */
#define	PC	0xf

enum tahoe_opermodes
  {
    literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
    bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
    immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
    longrel, longreldef
  };
typedef enum tahoe_opermodes tahoe_operandenum;

/*
 * A symbol to be the child of indirect callf:
 */
static Sym indirectchild;

static tahoe_operandenum tahoe_operandmode PARAMS ((unsigned char *));
static char *tahoe_operandname PARAMS ((tahoe_operandenum));
static long tahoe_operandlength PARAMS ((unsigned char *));
static bfd_signed_vma tahoe_offset PARAMS ((unsigned char *));
void tahoe_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));

static tahoe_operandenum
tahoe_operandmode (modep)
     unsigned char *modep;
{
  long usesreg = *modep & 0xf;

  switch ((*modep >> 4) & 0xf)
    {
    case 0:
    case 1:
    case 2:
    case 3:
      return literal;
    case 4:
      return indexed;
    case 5:
      return reg;
    case 6:
      return regdef;
    case 7:
      return autodec;
    case 8:
      return usesreg != 0xe ? autoinc : immediate;
    case 9:
      return usesreg != PC ? autoincdef : absolute;
    case 10:
      return usesreg != PC ? bytedisp : byterel;
    case 11:
      return usesreg != PC ? bytedispdef : bytereldef;
    case 12:
      return usesreg != PC ? worddisp : wordrel;
    case 13:
      return usesreg != PC ? worddispdef : wordreldef;
    case 14:
      return usesreg != PC ? longdisp : longrel;
    case 15:
      return usesreg != PC ? longdispdef : longreldef;
    }
  /* NOTREACHED */
  abort ();
}

static char *
tahoe_operandname (mode)
     tahoe_operandenum mode;
{

  switch (mode)
    {
    case literal:
      return "literal";
    case indexed:
      return "indexed";
    case reg:
      return "register";
    case regdef:
      return "register deferred";
    case autodec:
      return "autodecrement";
    case autoinc:
      return "autoincrement";
    case autoincdef:
      return "autoincrement deferred";
    case bytedisp:
      return "byte displacement";
    case bytedispdef:
      return "byte displacement deferred";
    case byterel:
      return "byte relative";
    case bytereldef:
      return "byte relative deferred";
    case worddisp:
      return "word displacement";
    case worddispdef:
      return "word displacement deferred";
    case wordrel:
      return "word relative";
    case wordreldef:
      return "word relative deferred";
    case immediate:
      return "immediate";
    case absolute:
      return "absolute";
    case longdisp:
      return "long displacement";
    case longdispdef:
      return "long displacement deferred";
    case longrel:
      return "long relative";
    case longreldef:
      return "long relative deferred";
    }
  /* NOTREACHED */
  abort ();
}

static long
tahoe_operandlength (modep)
     unsigned char *modep;
{

  switch (tahoe_operandmode (modep))
    {
    case literal:
    case reg:
    case regdef:
    case autodec:
    case autoinc:
    case autoincdef:
      return 1;
    case bytedisp:
    case bytedispdef:
    case byterel:
    case bytereldef:
      return 2;
    case worddisp:
    case worddispdef:
    case wordrel:
    case wordreldef:
      return 3;
    case immediate:
    case absolute:
    case longdisp:
    case longdispdef:
    case longrel:
    case longreldef:
      return 5;
    case indexed:
      return 1 + tahoe_operandlength (modep + 1);
    }
  /* NOTREACHED */
  abort ();
}

static bfd_signed_vma
tahoe_offset (modep)
     unsigned char *modep;
{
  tahoe_operandenum mode = tahoe_operandmode (modep);

  ++modep;				/* skip over the mode */
  switch (mode)
    {
    default:
      fprintf (stderr, "[reladdr] not relative address\n");
      return 0;
    case byterel:
      return 1 + bfd_get_signed_8 (core_bfd, modep);
    case wordrel:
      return 2 + bfd_get_signed_16 (core_bfd, modep);
    case longrel:
      return 4 + bfd_get_signed_32 (core_bfd, modep);
    }
}

void
tahoe_find_call (parent, p_lowpc, p_highpc)
     Sym *parent;
     bfd_vma p_lowpc;
     bfd_vma p_highpc;
{
  unsigned char *instructp;
  long length;
  Sym *child;
  tahoe_operandenum mode;
  tahoe_operandenum firstmode;
  bfd_vma pc, destpc;
  static boolean inited = false;

  if (!inited)
    {
      inited = true;
      sym_init (&indirectchild);
      indirectchild.cg.prop.fract = 1.0;
      indirectchild.cg.cyc.head = &indirectchild;
    }

  if (core_text_space == 0)
    {
      return;
    }
  if (p_lowpc < s_lowpc)
    {
      p_lowpc = s_lowpc;
    }
  if (p_highpc > s_highpc)
    {
      p_highpc = s_highpc;
    }
  DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
			  parent->name, (unsigned long) p_lowpc,
			  (unsigned long) p_highpc));
  for (pc = p_lowpc; pc < p_highpc; pc += length)
    {
      length = 1;
      instructp = ((unsigned char *) core_text_space
		   + pc - core_text_sect->vma);
      if ((*instructp & 0xff) == CALLF)
	{
	  /*
	   *    maybe a callf, better check it out.
	   *      skip the count of the number of arguments.
	   */
	  DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
				  (unsigned long) pc));
	  firstmode = tahoe_operandmode (instructp + length);
	  switch (firstmode)
	    {
	    case literal:
	    case immediate:
	      break;
	    default:
	      goto botched;
	    }
	  length += tahoe_operandlength (instructp + length);
	  mode = tahoe_operandmode (instructp + length);
	  DBG (CALLDEBUG,
	       printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
	       printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
	    );
	  switch (mode)
	    {
	    case regdef:
	    case bytedispdef:
	    case worddispdef:
	    case longdispdef:
	    case bytereldef:
	    case wordreldef:
	    case longreldef:
	      /*
	       *    indirect call: call through pointer
	       *      either  *d(r)   as a parameter or local
	       *              (r)     as a return value
	       *              *f      as a global pointer
	       *      [are there others that we miss?,
	       *       e.g. arrays of pointers to functions???]
	       */
	      arc_add (parent, &indirectchild, (unsigned long) 0);
	      length += tahoe_operandlength (instructp + length);
	      continue;
	    case byterel:
	    case wordrel:
	    case longrel:
	      /*
	       *    regular pc relative addressing
	       *      check that this is the address of
	       *      a function.
	       */
	      destpc = pc + tahoe_offset (instructp + length);
	      if (destpc >= s_lowpc && destpc <= s_highpc)
		{
		  child = sym_lookup (&symtab, destpc);
		  DBG (CALLDEBUG,
		       printf ("[findcall]\tdestpc 0x%lx",
			       (unsigned long) destpc);
		       printf (" child->name %s", child->name);
		       printf (" child->addr 0x%lx\n",
			       (unsigned long) child->addr);
		    );
		  if (child->addr == destpc)
		    {
		      /*
		       *    a hit
		       */
		      arc_add (parent, child, (unsigned long) 0);
		      length += tahoe_operandlength (instructp + length);
		      continue;
		    }
		  goto botched;
		}
	      /*
	       *    else:
	       *      it looked like a callf,
	       *      but it wasn't to anywhere.
	       */
	      goto botched;
	    default:
	    botched:
	      /*
	       *    something funny going on.
	       */
	      DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
	      length = 1;
	      continue;
	    }
	}
    }
}
Commit	Line	Data
252b5132	1	/*
0eee5820	2	* Copyright (c) 1983, 2001 Regents of the University of California.
252b5132 RH	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms are permitted
	6	* provided that: (1) source distributions retain this entire copyright
	7	* notice and comment, and (2) distributions including binaries display
	8	* the following acknowledgement: ``This product includes software
	9	* developed by the University of California, Berkeley and its contributors''
	10	* in the documentation or other materials provided with the distribution
	11	* and in all advertising materials mentioning features or use of this
	12	* software. Neither the name of the University nor the names of its
	13	* contributors may be used to endorse or promote products derived
	14	* from this software without specific prior written permission.
	15	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	16	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	17	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	18	*/
	19	#include "gprof.h"
6d9c411a AM	20	#include "search_list.h"
	21	#include "source.h"
	22	#include "symtab.h"
252b5132 RH	23	#include "cg_arcs.h"
	24	#include "corefile.h"
	25	#include "hist.h"
252b5132 RH	26
	27	/*
	28	* opcode of the `callf' instruction
	29	*/
	30	#define CALLF 0xfe
	31
	32	/*
	33	* register for pc relative addressing
	34	*/
	35	#define PC 0xf
	36
	37	enum tahoe_opermodes
	38	{
	39	literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
	40	bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
	41	immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
	42	longrel, longreldef
	43	};
	44	typedef enum tahoe_opermodes tahoe_operandenum;
	45
	46	/*
	47	* A symbol to be the child of indirect callf:
	48	*/
3b04e729	49	static Sym indirectchild;
252b5132	50
3b04e729 RH	51	static tahoe_operandenum tahoe_operandmode PARAMS ((unsigned char *));
	52	static char *tahoe_operandname PARAMS ((tahoe_operandenum));
	53	static long tahoe_operandlength PARAMS ((unsigned char *));
6d9c411a	54	static bfd_signed_vma tahoe_offset PARAMS ((unsigned char *));
5789ecea	55	void tahoe_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
252b5132	56
3b04e729	57	static tahoe_operandenum
252b5132 RH	58	tahoe_operandmode (modep)
	59	unsigned char *modep;
	60	{
6d9c411a	61	long usesreg = *modep & 0xf;
252b5132	62
6d9c411a	63	switch ((*modep >> 4) & 0xf)
252b5132 RH	64	{
	65	case 0:
	66	case 1:
	67	case 2:
	68	case 3:
	69	return literal;
	70	case 4:
	71	return indexed;
	72	case 5:
	73	return reg;
	74	case 6:
	75	return regdef;
	76	case 7:
	77	return autodec;
	78	case 8:
	79	return usesreg != 0xe ? autoinc : immediate;
	80	case 9:
	81	return usesreg != PC ? autoincdef : absolute;
	82	case 10:
	83	return usesreg != PC ? bytedisp : byterel;
	84	case 11:
	85	return usesreg != PC ? bytedispdef : bytereldef;
	86	case 12:
	87	return usesreg != PC ? worddisp : wordrel;
	88	case 13:
	89	return usesreg != PC ? worddispdef : wordreldef;
	90	case 14:
	91	return usesreg != PC ? longdisp : longrel;
	92	case 15:
	93	return usesreg != PC ? longdispdef : longreldef;
	94	}
	95	/* NOTREACHED */
	96	abort ();
	97	}
	98
3b04e729	99	static char *
252b5132 RH	100	tahoe_operandname (mode)
	101	tahoe_operandenum mode;
	102	{
	103
	104	switch (mode)
	105	{
	106	case literal:
	107	return "literal";
	108	case indexed:
	109	return "indexed";
	110	case reg:
	111	return "register";
	112	case regdef:
	113	return "register deferred";
	114	case autodec:
	115	return "autodecrement";
	116	case autoinc:
	117	return "autoincrement";
	118	case autoincdef:
	119	return "autoincrement deferred";
	120	case bytedisp:
	121	return "byte displacement";
	122	case bytedispdef:
	123	return "byte displacement deferred";
	124	case byterel:
	125	return "byte relative";
	126	case bytereldef:
	127	return "byte relative deferred";
	128	case worddisp:
	129	return "word displacement";
	130	case worddispdef:
	131	return "word displacement deferred";
	132	case wordrel:
	133	return "word relative";
	134	case wordreldef:
	135	return "word relative deferred";
	136	case immediate:
	137	return "immediate";
	138	case absolute:
	139	return "absolute";
	140	case longdisp:
	141	return "long displacement";
	142	case longdispdef:
	143	return "long displacement deferred";
	144	case longrel:
	145	return "long relative";
	146	case longreldef:
	147	return "long relative deferred";
	148	}
	149	/* NOTREACHED */
	150	abort ();
	151	}
	152
3b04e729	153	static long
252b5132 RH	154	tahoe_operandlength (modep)
	155	unsigned char *modep;
	156	{
	157
	158	switch (tahoe_operandmode (modep))
	159	{
	160	case literal:
	161	case reg:
	162	case regdef:
	163	case autodec:
	164	case autoinc:
	165	case autoincdef:
	166	return 1;
	167	case bytedisp:
	168	case bytedispdef:
	169	case byterel:
	170	case bytereldef:
	171	return 2;
	172	case worddisp:
	173	case worddispdef:
	174	case wordrel:
	175	case wordreldef:
	176	return 3;
	177	case immediate:
	178	case absolute:
	179	case longdisp:
	180	case longdispdef:
	181	case longrel:
	182	case longreldef:
	183	return 5;
	184	case indexed:
	185	return 1 + tahoe_operandlength (modep + 1);
	186	}
	187	/* NOTREACHED */
	188	abort ();
	189	}
	190
6d9c411a AM	191	static bfd_signed_vma
	192	tahoe_offset (modep)
	193	unsigned char *modep;
252b5132 RH	194	{
252b5132 RH	195	tahoe_operandenum mode = tahoe_operandmode (modep);
252b5132	196
6d9c411a	197	++modep; /* skip over the mode */
252b5132 RH	198	switch (mode)
	199	{
	200	default:
	201	fprintf (stderr, "[reladdr] not relative address\n");
6d9c411a	202	return 0;
252b5132	203	case byterel:
6d9c411a	204	return 1 + bfd_get_signed_8 (core_bfd, modep);
252b5132	205	case wordrel:
6d9c411a	206	return 2 + bfd_get_signed_16 (core_bfd, modep);
252b5132	207	case longrel:
6d9c411a	208	return 4 + bfd_get_signed_32 (core_bfd, modep);
252b5132 RH	209	}
	210	}
	211
	212	void
	213	tahoe_find_call (parent, p_lowpc, p_highpc)
	214	Sym *parent;
	215	bfd_vma p_lowpc;
	216	bfd_vma p_highpc;
	217	{
	218	unsigned char *instructp;
	219	long length;
	220	Sym *child;
	221	tahoe_operandenum mode;
	222	tahoe_operandenum firstmode;
6d9c411a	223	bfd_vma pc, destpc;
bde52789	224	static boolean inited = false;
252b5132 RH	225
	226	if (!inited)
	227	{
bde52789	228	inited = true;
252b5132 RH	229	sym_init (&indirectchild);
	230	indirectchild.cg.prop.fract = 1.0;
	231	indirectchild.cg.cyc.head = &indirectchild;
	232	}
	233
	234	if (core_text_space == 0)
	235	{
	236	return;
	237	}
	238	if (p_lowpc < s_lowpc)
	239	{
	240	p_lowpc = s_lowpc;
	241	}
	242	if (p_highpc > s_highpc)
	243	{
	244	p_highpc = s_highpc;
	245	}
	246	DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
fdcf7d43 ILT	247	parent->name, (unsigned long) p_lowpc,
fdcf7d43 ILT	248	(unsigned long) p_highpc));
6d9c411a	249	for (pc = p_lowpc; pc < p_highpc; pc += length)
252b5132 RH	250	{
252b5132 RH	251	length = 1;
6d9c411a AM	252	instructp = ((unsigned char *) core_text_space
	253	+ pc - core_text_sect->vma);
	254	if ((*instructp & 0xff) == CALLF)
252b5132 RH	255	{
	256	/*
	257	* maybe a callf, better check it out.
	258	* skip the count of the number of arguments.
	259	*/
0e69fcbc	260	DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
6d9c411a	261	(unsigned long) pc));
252b5132 RH	262	firstmode = tahoe_operandmode (instructp + length);
	263	switch (firstmode)
	264	{
	265	case literal:
	266	case immediate:
	267	break;
	268	default:
	269	goto botched;
	270	}
	271	length += tahoe_operandlength (instructp + length);
	272	mode = tahoe_operandmode (instructp + length);
	273	DBG (CALLDEBUG,
	274	printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
	275	printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
	276	);
	277	switch (mode)
	278	{
	279	case regdef:
	280	case bytedispdef:
	281	case worddispdef:
	282	case longdispdef:
	283	case bytereldef:
	284	case wordreldef:
	285	case longreldef:
	286	/*
	287	* indirect call: call through pointer
	288	* either *d(r) as a parameter or local
	289	* (r) as a return value
	290	* *f as a global pointer
	291	* [are there others that we miss?,
	292	* e.g. arrays of pointers to functions???]
	293	*/
	294	arc_add (parent, &indirectchild, (unsigned long) 0);
	295	length += tahoe_operandlength (instructp + length);
	296	continue;
	297	case byterel:
	298	case wordrel:
	299	case longrel:
	300	/*
	301	* regular pc relative addressing
0eee5820	302	* check that this is the address of
252b5132 RH	303	* a function.
252b5132 RH	304	*/
6d9c411a	305	destpc = pc + tahoe_offset (instructp + length);
252b5132 RH	306	if (destpc >= s_lowpc && destpc <= s_highpc)
	307	{
	308	child = sym_lookup (&symtab, destpc);
	309	DBG (CALLDEBUG,
fdcf7d43 ILT	310	printf ("[findcall]\tdestpc 0x%lx",
fdcf7d43 ILT	311	(unsigned long) destpc);
252b5132	312	printf (" child->name %s", child->name);
fdcf7d43 ILT	313	printf (" child->addr 0x%lx\n",
fdcf7d43 ILT	314	(unsigned long) child->addr);
252b5132 RH	315	);
	316	if (child->addr == destpc)
	317	{
	318	/*
	319	* a hit
	320	*/
	321	arc_add (parent, child, (unsigned long) 0);
	322	length += tahoe_operandlength (instructp + length);
	323	continue;
	324	}
	325	goto botched;
	326	}
	327	/*
	328	* else:
	329	* it looked like a callf,
	330	* but it wasn't to anywhere.
	331	*/
	332	goto botched;
	333	default:
	334	botched:
	335	/*
	336	* something funny going on.
	337	*/
	338	DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
	339	length = 1;
	340	continue;
	341	}
	342	}
	343	}
	344	}