5584f22bb3
the executable file, so it will work for both a.out and ELF format files. I have split the object format specific code into separate source files. It's cleaner than it was before, but it's still pretty crufty. Don't cheat on your make world for this update. A lot of things have to be rebuilt for it to work, including the compiler and all of the profiled libraries.
588 lines
14 KiB
C
588 lines
14 KiB
C
/*
|
|
* Copyright (c) 1983, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Berkeley and its contributors.
|
|
* 4. 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 BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static const char copyright[] =
|
|
"@(#) Copyright (c) 1983, 1993\n\
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)gprof.c 8.1 (Berkeley) 6/6/93";
|
|
#endif
|
|
static const char rcsid[] =
|
|
"$Id: gprof.c,v 1.7 1998/08/08 17:48:26 jdp Exp $";
|
|
#endif /* not lint */
|
|
|
|
#include <err.h>
|
|
#include "gprof.h"
|
|
|
|
static int valcmp(const void *, const void *);
|
|
|
|
|
|
static struct gmonhdr gmonhdr;
|
|
static int lflag;
|
|
static int Lflag;
|
|
|
|
main(argc, argv)
|
|
int argc;
|
|
char **argv;
|
|
{
|
|
char **sp;
|
|
nltype **timesortnlp;
|
|
char **defaultEs;
|
|
|
|
--argc;
|
|
argv++;
|
|
debug = 0;
|
|
bflag = TRUE;
|
|
while ( *argv != 0 && **argv == '-' ) {
|
|
(*argv)++;
|
|
switch ( **argv ) {
|
|
case 'a':
|
|
aflag = TRUE;
|
|
break;
|
|
case 'b':
|
|
bflag = FALSE;
|
|
break;
|
|
case 'C':
|
|
Cflag = TRUE;
|
|
cyclethreshold = atoi( *++argv );
|
|
break;
|
|
case 'c':
|
|
#if defined(vax) || defined(tahoe)
|
|
cflag = TRUE;
|
|
#else
|
|
errx(1, "-c isn't supported on this architecture yet");
|
|
#endif
|
|
break;
|
|
case 'd':
|
|
dflag = TRUE;
|
|
setlinebuf(stdout);
|
|
debug |= atoi( *++argv );
|
|
debug |= ANYDEBUG;
|
|
# ifdef DEBUG
|
|
printf("[main] debug = %d\n", debug);
|
|
# else not DEBUG
|
|
printf("gprof: -d ignored\n");
|
|
# endif DEBUG
|
|
break;
|
|
case 'E':
|
|
++argv;
|
|
addlist( Elist , *argv );
|
|
Eflag = TRUE;
|
|
addlist( elist , *argv );
|
|
eflag = TRUE;
|
|
break;
|
|
case 'e':
|
|
addlist( elist , *++argv );
|
|
eflag = TRUE;
|
|
break;
|
|
case 'F':
|
|
++argv;
|
|
addlist( Flist , *argv );
|
|
Fflag = TRUE;
|
|
addlist( flist , *argv );
|
|
fflag = TRUE;
|
|
break;
|
|
case 'f':
|
|
addlist( flist , *++argv );
|
|
fflag = TRUE;
|
|
break;
|
|
case 'k':
|
|
addlist( kfromlist , *++argv );
|
|
addlist( ktolist , *++argv );
|
|
kflag = TRUE;
|
|
break;
|
|
case 'l':
|
|
lflag = 1;
|
|
Lflag = 0;
|
|
break;
|
|
case 'L':
|
|
Lflag = 1;
|
|
lflag = 0;
|
|
break;
|
|
case 's':
|
|
sflag = TRUE;
|
|
break;
|
|
case 'u':
|
|
uflag = TRUE;
|
|
break;
|
|
case 'z':
|
|
zflag = TRUE;
|
|
break;
|
|
}
|
|
argv++;
|
|
}
|
|
if ( *argv != 0 ) {
|
|
a_outname = *argv;
|
|
argv++;
|
|
} else {
|
|
a_outname = A_OUTNAME;
|
|
}
|
|
if ( *argv != 0 ) {
|
|
gmonname = *argv;
|
|
argv++;
|
|
} else {
|
|
gmonname = GMONNAME;
|
|
}
|
|
/*
|
|
* get information from the executable file.
|
|
*/
|
|
if (elf_getnfile(a_outname, &defaultEs) == -1 &&
|
|
aout_getnfile(a_outname, &defaultEs) == -1)
|
|
errx(1, "%s: bad format", a_outname);
|
|
/*
|
|
* sort symbol table.
|
|
*/
|
|
qsort(nl, nname, sizeof(nltype), valcmp);
|
|
/*
|
|
* turn off default functions
|
|
*/
|
|
for ( sp = defaultEs ; *sp ; sp++ ) {
|
|
Eflag = TRUE;
|
|
addlist( Elist , *sp );
|
|
eflag = TRUE;
|
|
addlist( elist , *sp );
|
|
}
|
|
/*
|
|
* get information about mon.out file(s).
|
|
*/
|
|
do {
|
|
getpfile( gmonname );
|
|
if ( *argv != 0 ) {
|
|
gmonname = *argv;
|
|
}
|
|
} while ( *argv++ != 0 );
|
|
/*
|
|
* how many ticks per second?
|
|
* if we can't tell, report time in ticks.
|
|
*/
|
|
if (hz == 0) {
|
|
hz = 1;
|
|
fprintf(stderr, "time is in ticks, not seconds\n");
|
|
}
|
|
/*
|
|
* dump out a gmon.sum file if requested
|
|
*/
|
|
if ( sflag ) {
|
|
dumpsum( GMONSUM );
|
|
}
|
|
/*
|
|
* assign samples to procedures
|
|
*/
|
|
asgnsamples();
|
|
/*
|
|
* assemble the dynamic profile
|
|
*/
|
|
timesortnlp = doarcs();
|
|
/*
|
|
* print the dynamic profile
|
|
*/
|
|
if(!lflag) {
|
|
printgprof( timesortnlp );
|
|
}
|
|
/*
|
|
* print the flat profile
|
|
*/
|
|
if(!Lflag) {
|
|
printprof();
|
|
}
|
|
/*
|
|
* print the index
|
|
*/
|
|
printindex();
|
|
done();
|
|
}
|
|
|
|
/*
|
|
* information from a gmon.out file is in two parts:
|
|
* an array of sampling hits within pc ranges,
|
|
* and the arcs.
|
|
*/
|
|
getpfile(filename)
|
|
char *filename;
|
|
{
|
|
FILE *pfile;
|
|
FILE *openpfile();
|
|
struct rawarc arc;
|
|
|
|
pfile = openpfile(filename);
|
|
readsamples(pfile);
|
|
/*
|
|
* the rest of the file consists of
|
|
* a bunch of <from,self,count> tuples.
|
|
*/
|
|
while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) {
|
|
# ifdef DEBUG
|
|
if ( debug & SAMPLEDEBUG ) {
|
|
printf( "[getpfile] frompc 0x%x selfpc 0x%x count %d\n" ,
|
|
arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
|
|
}
|
|
# endif DEBUG
|
|
/*
|
|
* add this arc
|
|
*/
|
|
tally( &arc );
|
|
}
|
|
fclose(pfile);
|
|
}
|
|
|
|
FILE *
|
|
openpfile(filename)
|
|
char *filename;
|
|
{
|
|
struct gmonhdr tmp;
|
|
FILE *pfile;
|
|
int size;
|
|
int rate;
|
|
|
|
if((pfile = fopen(filename, "r")) == NULL) {
|
|
perror(filename);
|
|
done();
|
|
}
|
|
fread(&tmp, sizeof(struct gmonhdr), 1, pfile);
|
|
if ( s_highpc != 0 && ( tmp.lpc != gmonhdr.lpc ||
|
|
tmp.hpc != gmonhdr.hpc || tmp.ncnt != gmonhdr.ncnt ) ) {
|
|
warnx("%s: incompatible with first gmon file", filename);
|
|
done();
|
|
}
|
|
gmonhdr = tmp;
|
|
if ( gmonhdr.version == GMONVERSION ) {
|
|
rate = gmonhdr.profrate;
|
|
size = sizeof(struct gmonhdr);
|
|
} else {
|
|
fseek(pfile, sizeof(struct ophdr), SEEK_SET);
|
|
size = sizeof(struct ophdr);
|
|
gmonhdr.profrate = rate = hertz();
|
|
gmonhdr.version = GMONVERSION;
|
|
}
|
|
if (hz == 0) {
|
|
hz = rate;
|
|
} else if (hz != rate) {
|
|
fprintf(stderr,
|
|
"%s: profile clock rate (%d) %s (%d) in first gmon file\n",
|
|
filename, rate, "incompatible with clock rate", hz);
|
|
done();
|
|
}
|
|
s_lowpc = (unsigned long) gmonhdr.lpc;
|
|
s_highpc = (unsigned long) gmonhdr.hpc;
|
|
lowpc = (unsigned long)gmonhdr.lpc / sizeof(UNIT);
|
|
highpc = (unsigned long)gmonhdr.hpc / sizeof(UNIT);
|
|
sampbytes = gmonhdr.ncnt - size;
|
|
nsamples = sampbytes / sizeof (UNIT);
|
|
# ifdef DEBUG
|
|
if ( debug & SAMPLEDEBUG ) {
|
|
printf( "[openpfile] hdr.lpc 0x%x hdr.hpc 0x%x hdr.ncnt %d\n",
|
|
gmonhdr.lpc , gmonhdr.hpc , gmonhdr.ncnt );
|
|
printf( "[openpfile] s_lowpc 0x%x s_highpc 0x%x\n" ,
|
|
s_lowpc , s_highpc );
|
|
printf( "[openpfile] lowpc 0x%x highpc 0x%x\n" ,
|
|
lowpc , highpc );
|
|
printf( "[openpfile] sampbytes %d nsamples %d\n" ,
|
|
sampbytes , nsamples );
|
|
printf( "[openpfile] sample rate %d\n" , hz );
|
|
}
|
|
# endif DEBUG
|
|
return(pfile);
|
|
}
|
|
|
|
tally( rawp )
|
|
struct rawarc *rawp;
|
|
{
|
|
nltype *parentp;
|
|
nltype *childp;
|
|
|
|
parentp = nllookup( rawp -> raw_frompc );
|
|
childp = nllookup( rawp -> raw_selfpc );
|
|
if ( parentp == 0 || childp == 0 )
|
|
return;
|
|
if ( kflag
|
|
&& onlist( kfromlist , parentp -> name )
|
|
&& onlist( ktolist , childp -> name ) ) {
|
|
return;
|
|
}
|
|
childp -> ncall += rawp -> raw_count;
|
|
# ifdef DEBUG
|
|
if ( debug & TALLYDEBUG ) {
|
|
printf( "[tally] arc from %s to %s traversed %d times\n" ,
|
|
parentp -> name , childp -> name , rawp -> raw_count );
|
|
}
|
|
# endif DEBUG
|
|
addarc( parentp , childp , rawp -> raw_count );
|
|
}
|
|
|
|
/*
|
|
* dump out the gmon.sum file
|
|
*/
|
|
dumpsum( sumfile )
|
|
char *sumfile;
|
|
{
|
|
register nltype *nlp;
|
|
register arctype *arcp;
|
|
struct rawarc arc;
|
|
FILE *sfile;
|
|
|
|
if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) {
|
|
perror( sumfile );
|
|
done();
|
|
}
|
|
/*
|
|
* dump the header; use the last header read in
|
|
*/
|
|
if ( fwrite( &gmonhdr , sizeof gmonhdr , 1 , sfile ) != 1 ) {
|
|
perror( sumfile );
|
|
done();
|
|
}
|
|
/*
|
|
* dump the samples
|
|
*/
|
|
if (fwrite(samples, sizeof (UNIT), nsamples, sfile) != nsamples) {
|
|
perror( sumfile );
|
|
done();
|
|
}
|
|
/*
|
|
* dump the normalized raw arc information
|
|
*/
|
|
for ( nlp = nl ; nlp < npe ; nlp++ ) {
|
|
for ( arcp = nlp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
|
|
arc.raw_frompc = arcp -> arc_parentp -> value;
|
|
arc.raw_selfpc = arcp -> arc_childp -> value;
|
|
arc.raw_count = arcp -> arc_count;
|
|
if ( fwrite ( &arc , sizeof arc , 1 , sfile ) != 1 ) {
|
|
perror( sumfile );
|
|
done();
|
|
}
|
|
# ifdef DEBUG
|
|
if ( debug & SAMPLEDEBUG ) {
|
|
printf( "[dumpsum] frompc 0x%x selfpc 0x%x count %d\n" ,
|
|
arc.raw_frompc , arc.raw_selfpc , arc.raw_count );
|
|
}
|
|
# endif DEBUG
|
|
}
|
|
}
|
|
fclose( sfile );
|
|
}
|
|
|
|
static int
|
|
valcmp(v1, v2)
|
|
const void *v1;
|
|
const void *v2;
|
|
{
|
|
const nltype *p1 = (const nltype *)v1;
|
|
const nltype *p2 = (const nltype *)v2;
|
|
|
|
if ( p1 -> value < p2 -> value ) {
|
|
return LESSTHAN;
|
|
}
|
|
if ( p1 -> value > p2 -> value ) {
|
|
return GREATERTHAN;
|
|
}
|
|
return EQUALTO;
|
|
}
|
|
|
|
readsamples(pfile)
|
|
FILE *pfile;
|
|
{
|
|
register i;
|
|
UNIT sample;
|
|
|
|
if (samples == 0) {
|
|
samples = (UNIT *) calloc(sampbytes, sizeof (UNIT));
|
|
if (samples == 0) {
|
|
warnx("no room for %d sample pc's", sampbytes / sizeof (UNIT));
|
|
done();
|
|
}
|
|
}
|
|
for (i = 0; i < nsamples; i++) {
|
|
fread(&sample, sizeof (UNIT), 1, pfile);
|
|
if (feof(pfile))
|
|
break;
|
|
samples[i] += sample;
|
|
}
|
|
if (i != nsamples) {
|
|
warnx("unexpected EOF after reading %d/%d samples", --i , nsamples );
|
|
done();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Assign samples to the procedures to which they belong.
|
|
*
|
|
* There are three cases as to where pcl and pch can be
|
|
* with respect to the routine entry addresses svalue0 and svalue1
|
|
* as shown in the following diagram. overlap computes the
|
|
* distance between the arrows, the fraction of the sample
|
|
* that is to be credited to the routine which starts at svalue0.
|
|
*
|
|
* svalue0 svalue1
|
|
* | |
|
|
* v v
|
|
*
|
|
* +-----------------------------------------------+
|
|
* | |
|
|
* | ->| |<- ->| |<- ->| |<- |
|
|
* | | | | | |
|
|
* +---------+ +---------+ +---------+
|
|
*
|
|
* ^ ^ ^ ^ ^ ^
|
|
* | | | | | |
|
|
* pcl pch pcl pch pcl pch
|
|
*
|
|
* For the vax we assert that samples will never fall in the first
|
|
* two bytes of any routine, since that is the entry mask,
|
|
* thus we give call alignentries() to adjust the entry points if
|
|
* the entry mask falls in one bucket but the code for the routine
|
|
* doesn't start until the next bucket. In conjunction with the
|
|
* alignment of routine addresses, this should allow us to have
|
|
* only one sample for every four bytes of text space and never
|
|
* have any overlap (the two end cases, above).
|
|
*/
|
|
asgnsamples()
|
|
{
|
|
register int j;
|
|
UNIT ccnt;
|
|
double time;
|
|
unsigned long pcl, pch;
|
|
register int i;
|
|
unsigned long overlap;
|
|
unsigned long svalue0, svalue1;
|
|
|
|
/* read samples and assign to namelist symbols */
|
|
scale = highpc - lowpc;
|
|
scale /= nsamples;
|
|
alignentries();
|
|
for (i = 0, j = 1; i < nsamples; i++) {
|
|
ccnt = samples[i];
|
|
if (ccnt == 0)
|
|
continue;
|
|
pcl = lowpc + scale * i;
|
|
pch = lowpc + scale * (i + 1);
|
|
time = ccnt;
|
|
# ifdef DEBUG
|
|
if ( debug & SAMPLEDEBUG ) {
|
|
printf( "[asgnsamples] pcl 0x%x pch 0x%x ccnt %d\n" ,
|
|
pcl , pch , ccnt );
|
|
}
|
|
# endif DEBUG
|
|
totime += time;
|
|
for (j = j - 1; j < nname; j++) {
|
|
svalue0 = nl[j].svalue;
|
|
svalue1 = nl[j+1].svalue;
|
|
/*
|
|
* if high end of tick is below entry address,
|
|
* go for next tick.
|
|
*/
|
|
if (pch < svalue0)
|
|
break;
|
|
/*
|
|
* if low end of tick into next routine,
|
|
* go for next routine.
|
|
*/
|
|
if (pcl >= svalue1)
|
|
continue;
|
|
overlap = min(pch, svalue1) - max(pcl, svalue0);
|
|
if (overlap > 0) {
|
|
# ifdef DEBUG
|
|
if (debug & SAMPLEDEBUG) {
|
|
printf("[asgnsamples] (0x%x->0x%x-0x%x) %s gets %f ticks %d overlap\n",
|
|
nl[j].value/sizeof(UNIT), svalue0, svalue1,
|
|
nl[j].name,
|
|
overlap * time / scale, overlap);
|
|
}
|
|
# endif DEBUG
|
|
nl[j].time += overlap * time / scale;
|
|
}
|
|
}
|
|
}
|
|
# ifdef DEBUG
|
|
if (debug & SAMPLEDEBUG) {
|
|
printf("[asgnsamples] totime %f\n", totime);
|
|
}
|
|
# endif DEBUG
|
|
}
|
|
|
|
|
|
unsigned long
|
|
min(a, b)
|
|
unsigned long a,b;
|
|
{
|
|
if (a<b)
|
|
return(a);
|
|
return(b);
|
|
}
|
|
|
|
unsigned long
|
|
max(a, b)
|
|
unsigned long a,b;
|
|
{
|
|
if (a>b)
|
|
return(a);
|
|
return(b);
|
|
}
|
|
|
|
/*
|
|
* calculate scaled entry point addresses (to save time in asgnsamples),
|
|
* and possibly push the scaled entry points over the entry mask,
|
|
* if it turns out that the entry point is in one bucket and the code
|
|
* for a routine is in the next bucket.
|
|
*/
|
|
alignentries()
|
|
{
|
|
register struct nl *nlp;
|
|
unsigned long bucket_of_entry;
|
|
unsigned long bucket_of_code;
|
|
|
|
for (nlp = nl; nlp < npe; nlp++) {
|
|
nlp -> svalue = nlp -> value / sizeof(UNIT);
|
|
bucket_of_entry = (nlp->svalue - lowpc) / scale;
|
|
bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale;
|
|
if (bucket_of_entry < bucket_of_code) {
|
|
# ifdef DEBUG
|
|
if (debug & SAMPLEDEBUG) {
|
|
printf("[alignentries] pushing svalue 0x%x to 0x%x\n",
|
|
nlp->svalue, nlp->svalue + UNITS_TO_CODE);
|
|
}
|
|
# endif DEBUG
|
|
nlp->svalue += UNITS_TO_CODE;
|
|
}
|
|
}
|
|
}
|
|
|
|
done()
|
|
{
|
|
|
|
exit(0);
|
|
}
|