[unix-history] / usr / src / usr.bin / gprof / tahoe.c

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not 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 MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint
static char sccsid[] = "@(#)tahoe.c	1.4 (Berkeley) %G%";
#endif /* not lint */

#include	"gprof.h"

    /*
     *	a namelist entry to be the child of indirect callf
     */
nltype	indirectchild = {
	"(*)" ,				/* the name */
	(unsigned long) 0 ,		/* the pc entry point */
	(unsigned long) 0 ,		/* entry point aligned to histogram */
	(double) 0.0 ,			/* ticks in this routine */
	(double) 0.0 ,			/* cumulative ticks in children */
	(long) 0 ,			/* how many times called */
	(long) 0 ,			/* how many calls to self */
	(double) 1.0 ,			/* propagation fraction */
	(double) 0.0 ,			/* self propagation time */
	(double) 0.0 ,			/* child propagation time */
	(bool) 0 ,			/* print flag */
	(int) 0 ,			/* index in the graph list */
	(int) 0 , 			/* graph call chain top-sort order */
	(int) 0 ,			/* internal number of cycle on */
	(struct nl *) &indirectchild ,	/* pointer to head of cycle */
	(struct nl *) 0 ,		/* pointer to next member of cycle */
	(arctype *) 0 ,			/* list of caller arcs */
	(arctype *) 0 			/* list of callee arcs */
    };

operandenum
operandmode( modep )
    unsigned char	*modep;
{
    long	usesreg = ((long)*modep) & 0xf;
    
    switch ( ((long)*modep) >> 4 ) {
	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 */
}

char *
operandname( mode )
    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 */
}

long
operandlength( modep )
    unsigned char	*modep;
{
    
    switch ( 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+operandlength( modep + 1 );
    }
    /* NOTREACHED */
}

unsigned long
reladdr( modep )
    char	*modep;
{
    operandenum	mode = operandmode( modep );
    char	*cp;
    short	*sp;
    long	*lp;
    int		i;
    long	value = 0;

    cp = modep;
    cp += 1;			/* skip over the mode */
    switch ( mode ) {
	default:
	    fprintf( stderr , "[reladdr] not relative address\n" );
	    return (unsigned long) modep;
	case byterel:
	    return (unsigned long) ( cp + sizeof *cp + *cp );
	case wordrel:
	    for (i = 0; i < sizeof *sp; i++)
		value = (value << 8) + (cp[i] & 0xff);
	    return (unsigned long) ( cp + sizeof *sp + value );
	case longrel:
	    for (i = 0; i < sizeof *lp; i++)
		value = (value << 8) + (cp[i] & 0xff);
	    return (unsigned long) ( cp + sizeof *lp + value );
    }
}

findcall( parentp , p_lowpc , p_highpc )
    nltype		*parentp;
    unsigned long	p_lowpc;
    unsigned long	p_highpc;
{
    unsigned char	*instructp;
    long		length;
    nltype		*childp;
    operandenum		mode;
    operandenum		firstmode;
    unsigned long	destpc;

    if ( textspace == 0 ) {
	return;
    }
    if ( p_lowpc < s_lowpc ) {
	p_lowpc = s_lowpc;
    }
    if ( p_highpc > s_highpc ) {
	p_highpc = s_highpc;
    }
#   ifdef DEBUG
	if ( debug & CALLDEBUG ) {
	    printf( "[findcall] %s: 0x%x to 0x%x\n" ,
		    parentp -> name , p_lowpc , p_highpc );
	}
#   endif DEBUG
    for (   instructp = textspace + p_lowpc ;
	    instructp < textspace + p_highpc ;
	    instructp += length ) {
	length = 1;
	if ( *instructp == CALLF ) {
		/*
		 *	maybe a callf, better check it out.
		 *	skip the count of the number of arguments.
		 */
#	    ifdef DEBUG
		if ( debug & CALLDEBUG ) {
		    printf( "[findcall]\t0x%x:callf" , instructp - textspace );
		}
#	    endif DEBUG
	    firstmode = operandmode( instructp+length );
	    switch ( firstmode ) {
		case literal:
		case immediate:
		    break;
		default:
		    goto botched;
	    }
	    length += operandlength( instructp+length );
	    mode = operandmode( instructp + length );
#	    ifdef DEBUG
		if ( debug & CALLDEBUG ) {
		    printf( "\tfirst operand is %s", operandname( firstmode ) );
		    printf( "\tsecond operand is %s\n" , operandname( mode ) );
		}
#	    endif DEBUG
	    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???]
			 */
		    addarc( parentp , &indirectchild , (long) 0 );
		    length += operandlength( instructp + length );
		    continue;
		case byterel:
		case wordrel:
		case longrel:
			/*
			 *	regular pc relative addressing
			 *	check that this is the address of 
			 *	a function.
			 */
		    destpc = reladdr( instructp+length )
				- (unsigned long) textspace;
		    if ( destpc >= s_lowpc && destpc <= s_highpc ) {
			childp = nllookup( destpc );
#			ifdef DEBUG
			    if ( debug & CALLDEBUG ) {
				printf( "[findcall]\tdestpc 0x%x" , destpc );
				printf( " childp->name %s" , childp -> name );
				printf( " childp->value 0x%x\n" ,
					childp -> value );
			    }
#			endif DEBUG
			if ( childp -> value == destpc ) {
				/*
				 *	a hit
				 */
			    addarc( parentp , childp , (long) 0 );
			    length += 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.
			 */
#		    ifdef DEBUG
			if ( debug & CALLDEBUG ) {
			    printf( "[findcall]\tbut it's a botch\n" );
			}
#		    endif DEBUG
		    length = 1;
		    continue;
	    }
	}
    }
}
Commit	Line	Data
ddb85eed KB	1	/*
	2	* Copyright (c) 1983 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms are permitted
2124b336 KB	6	* provided that the above copyright notice and this paragraph are
	7	* duplicated in all such forms and that any documentation,
	8	* advertising materials, and other materials related to such
	9	* distribution and use acknowledge that the software was developed
	10	* by the University of California, Berkeley. The name of the
	11	* University may not be used to endorse or promote products derived
	12	* from this software without specific prior written permission.
	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	15	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
ddb85eed KB	16	*/
ddb85eed KB	17
82a8b820	18	#ifndef lint
2124b336	19	static char sccsid[] = "@(#)tahoe.c 1.4 (Berkeley) %G%";
ddb85eed	20	#endif /* not lint */
82a8b820 SL	21
	22	#include "gprof.h"
	23
	24	/*
	25	* a namelist entry to be the child of indirect callf
	26	*/
	27	nltype indirectchild = {
	28	"()" , / the name */
	29	(unsigned long) 0 , /* the pc entry point */
	30	(unsigned long) 0 , /* entry point aligned to histogram */
	31	(double) 0.0 , /* ticks in this routine */
	32	(double) 0.0 , /* cumulative ticks in children */
	33	(long) 0 , /* how many times called */
	34	(long) 0 , /* how many calls to self */
	35	(double) 1.0 , /* propagation fraction */
	36	(double) 0.0 , /* self propagation time */
	37	(double) 0.0 , /* child propagation time */
	38	(bool) 0 , /* print flag */
	39	(int) 0 , /* index in the graph list */
	40	(int) 0 , /* graph call chain top-sort order */
	41	(int) 0 , /* internal number of cycle on */
	42	(struct nl ) &indirectchild , / pointer to head of cycle */
	43	(struct nl ) 0 , / pointer to next member of cycle */
	44	(arctype ) 0 , / list of caller arcs */
	45	(arctype ) 0 / list of callee arcs */
	46	};
	47
	48	operandenum
	49	operandmode( modep )
	50	unsigned char *modep;
	51	{
	52	long usesreg = ((long)*modep) & 0xf;
	53
	54	switch ( ((long)*modep) >> 4 ) {
	55	case 0:
	56	case 1:
	57	case 2:
	58	case 3:
	59	return literal;
	60	case 4:
	61	return indexed;
	62	case 5:
	63	return reg;
	64	case 6:
	65	return regdef;
	66	case 7:
	67	return autodec;
	68	case 8:
	69	return ( usesreg != 0xe ? autoinc : immediate );
	70	case 9:
	71	return ( usesreg != PC ? autoincdef : absolute );
	72	case 10:
	73	return ( usesreg != PC ? bytedisp : byterel );
	74	case 11:
	75	return ( usesreg != PC ? bytedispdef : bytereldef );
	76	case 12:
	77	return ( usesreg != PC ? worddisp : wordrel );
	78	case 13:
	79	return ( usesreg != PC ? worddispdef : wordreldef );
	80	case 14:
	81	return ( usesreg != PC ? longdisp : longrel );
	82	case 15:
	83	return ( usesreg != PC ? longdispdef : longreldef );
	84	}
85	/* NOTREACHED */
86	}
87
88	char *
89	operandname( mode )
90	operandenum mode;
91	{
92
93	switch ( mode ) {
94	case literal:
95	return "literal";
96	case indexed:
97	return "indexed";
98	case reg:
99	return "register";
100	case regdef:
101	return "register deferred";
102	case autodec:
103	return "autodecrement";
104	case autoinc:
105	return "autoincrement";
106	case autoincdef:
107	return "autoincrement deferred";
108	case bytedisp:
109	return "byte displacement";
110	case bytedispdef:
111	return "byte displacement deferred";
112	case byterel:
113	return "byte relative";
114	case bytereldef:
115	return "byte relative deferred";
116	case worddisp:
117	return "word displacement";
118	case worddispdef:
119	return "word displacement deferred";
120	case wordrel:
121	return "word relative";
122	case wordreldef:
123	return "word relative deferred";
124	case immediate:
125	return "immediate";
126	case absolute:
127	return "absolute";
128	case longdisp:
129	return "long displacement";
130	case longdispdef:
131	return "long displacement deferred";
132	case longrel:
133	return "long relative";
134	case longreldef:
135	return "long relative deferred";
136	}
137	/* NOTREACHED */
138	}
139
140	long
141	operandlength( modep )
142	unsigned char *modep;
143	{
144
145	switch ( operandmode( modep ) ) {
146	case literal:
147	case reg:
148	case regdef:
149	case autodec:
150	case autoinc:
151	case autoincdef:
152	return 1;
153	case bytedisp:
154	case bytedispdef:
155	case byterel:
156	case bytereldef:
157	return 2;
158	case worddisp:
159	case worddispdef:
160	case wordrel:
161	case wordreldef:
162	return 3;
163	case immediate:
164	case absolute:
165	case longdisp:
166	case longdispdef:
167	case longrel:
168	case longreldef:
169	return 5;
170	case indexed:
171	return 1+operandlength( modep + 1 );
172	}
173	/* NOTREACHED */
174	}
175
176	unsigned long
177	reladdr( modep )
178	char *modep;
179	{
180	operandenum mode = operandmode( modep );
181	char *cp;
182	short *sp;
183	long *lp;
184	int i;
185	long value = 0;
186
187	cp = modep;
188	cp += 1; /* skip over the mode */
189	switch ( mode ) {
190	default:
191	fprintf( stderr , "[reladdr] not relative address\n" );
192	return (unsigned long) modep;
193	case byterel:
194	return (unsigned long) ( cp + sizeof cp + cp );
195	case wordrel:
196	for (i = 0; i < sizeof *sp; i++)
197	value = (value << 8) + (cp[i] & 0xff);
198	return (unsigned long) ( cp + sizeof *sp + value );
199	case longrel:
200	for (i = 0; i < sizeof *lp; i++)
201	value = (value << 8) + (cp[i] & 0xff);
202	return (unsigned long) ( cp + sizeof *lp + value );
203	}
204	}
205
da50c4dd	206	findcall( parentp , p_lowpc , p_highpc )
82a8b820 SL	207	nltype *parentp;
	208	unsigned long p_lowpc;
	209	unsigned long p_highpc;
	210	{
	211	unsigned char *instructp;
	212	long length;
	213	nltype *childp;
	214	operandenum mode;
	215	operandenum firstmode;
	216	unsigned long destpc;
	217
	218	if ( textspace == 0 ) {
	219	return;
	220	}
	221	if ( p_lowpc < s_lowpc ) {
	222	p_lowpc = s_lowpc;
	223	}
	224	if ( p_highpc > s_highpc ) {
	225	p_highpc = s_highpc;
	226	}
	227	# ifdef DEBUG
	228	if ( debug & CALLDEBUG ) {
da50c4dd	229	printf( "[findcall] %s: 0x%x to 0x%x\n" ,
82a8b820 SL	230	parentp -> name , p_lowpc , p_highpc );
	231	}
	232	# endif DEBUG
	233	for ( instructp = textspace + p_lowpc ;
	234	instructp < textspace + p_highpc ;
	235	instructp += length ) {
	236	length = 1;
	237	if ( *instructp == CALLF ) {
	238	/*
	239	* maybe a callf, better check it out.
	240	* skip the count of the number of arguments.
	241	*/
	242	# ifdef DEBUG
	243	if ( debug & CALLDEBUG ) {
da50c4dd	244	printf( "[findcall]\t0x%x:callf" , instructp - textspace );
82a8b820 SL	245	}
	246	# endif DEBUG
	247	firstmode = operandmode( instructp+length );
	248	switch ( firstmode ) {
	249	case literal:
	250	case immediate:
	251	break;
	252	default:
	253	goto botched;
	254	}
	255	length += operandlength( instructp+length );
	256	mode = operandmode( instructp + length );
	257	# ifdef DEBUG
	258	if ( debug & CALLDEBUG ) {
	259	printf( "\tfirst operand is %s", operandname( firstmode ) );
	260	printf( "\tsecond operand is %s\n" , operandname( mode ) );
	261	}
	262	# endif DEBUG
	263	switch ( mode ) {
	264	case regdef:
	265	case bytedispdef:
	266	case worddispdef:
	267	case longdispdef:
	268	case bytereldef:
	269	case wordreldef:
	270	case longreldef:
	271	/*
	272	* indirect call: call through pointer
	273	* either *d(r) as a parameter or local
	274	* (r) as a return value
	275	* *f as a global pointer
	276	* [are there others that we miss?,
	277	* e.g. arrays of pointers to functions???]
	278	*/
	279	addarc( parentp , &indirectchild , (long) 0 );
	280	length += operandlength( instructp + length );
	281	continue;
	282	case byterel:
	283	case wordrel:
	284	case longrel:
	285	/*
	286	* regular pc relative addressing
	287	* check that this is the address of
	288	* a function.
	289	*/
	290	destpc = reladdr( instructp+length )
	291	- (unsigned long) textspace;
	292	if ( destpc >= s_lowpc && destpc <= s_highpc ) {
	293	childp = nllookup( destpc );
	294	# ifdef DEBUG
	295	if ( debug & CALLDEBUG ) {
da50c4dd	296	printf( "[findcall]\tdestpc 0x%x" , destpc );
82a8b820 SL	297	printf( " childp->name %s" , childp -> name );
	298	printf( " childp->value 0x%x\n" ,
	299	childp -> value );
	300	}
	301	# endif DEBUG
	302	if ( childp -> value == destpc ) {
	303	/*
	304	* a hit
	305	*/
	306	addarc( parentp , childp , (long) 0 );
	307	length += operandlength( instructp + length );
	308	continue;
	309	}
	310	goto botched;
	311	}
	312	/*
	313	* else:
	314	* it looked like a callf,
	315	* but it wasn't to anywhere.
	316	*/
	317	goto botched;
	318	default:
	319	botched:
	320	/*
	321	* something funny going on.
	322	*/
	323	# ifdef DEBUG
	324	if ( debug & CALLDEBUG ) {
da50c4dd	325	printf( "[findcall]\tbut it's a botch\n" );
82a8b820 SL	326	}
	327	# endif DEBUG
	328	length = 1;
	329	continue;
	330	}
	331	}
	332	}
	333	}