Index: head/usr.bin/gprof/aout.c =================================================================== --- head/usr.bin/gprof/aout.c (revision 299876) +++ head/usr.bin/gprof/aout.c (revision 299877) @@ -1,229 +1,229 @@ /*- * 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. * 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. */ #if 0 /* From: */ #ifndef lint static char sccsid[] = "@(#)gprof.c 8.1 (Berkeley) 6/6/93"; #endif /* not lint */ #endif #include __FBSDID("$FreeBSD$"); #include #include #include #include #include "gprof.h" static void getstrtab(FILE *, const char *); static void getsymtab(FILE *, const char *); static void gettextspace(FILE *); static bool funcsymbol(struct nlist *); static char *strtab; /* string table in core */ static long ssiz; /* size of the string table */ static struct exec xbuf; /* exec header of a.out */ /* Things which get -E excluded by default. */ static char *excludes[] = { "mcount", "__mcleanup", NULL }; /* * Set up string and symbol tables from a.out. * and optionally the text space. * On return symbol table is sorted by value. * * Returns 0 on success, -1 on failure. */ int aout_getnfile(const char *filename, char ***defaultEs) { FILE *nfile; nfile = fopen( filename ,"r"); if (nfile == NULL) err( 1 , "%s", filename ); fread(&xbuf, 1, sizeof(xbuf), nfile); if (N_BADMAG(xbuf)) { fclose(nfile); return -1; } getstrtab(nfile, filename); getsymtab(nfile, filename); gettextspace( nfile ); fclose(nfile); # ifdef DEBUG if ( debug & AOUTDEBUG ) { register int j; for (j = 0; j < nname; j++){ printf("[getnfile] 0X%08lx\t%s\n", nl[j].value, nl[j].name); } } # endif /* DEBUG */ *defaultEs = excludes; return 0; } static void getstrtab(FILE *nfile, const char *filename) { fseek(nfile, (long)(N_SYMOFF(xbuf) + xbuf.a_syms), 0); if (fread(&ssiz, sizeof (ssiz), 1, nfile) == 0) errx( 1 , "%s: no string table (old format?)" , filename ); strtab = calloc(ssiz, 1); if (strtab == NULL) errx( 1 , "%s: no room for %ld bytes of string table", filename , ssiz); if (fread(strtab+sizeof(ssiz), ssiz-sizeof(ssiz), 1, nfile) != 1) errx( 1 , "%s: error reading string table" , filename ); } /* * Read in symbol table */ static void getsymtab(FILE *nfile, const char *filename) { register long i; int askfor; struct nlist nbuf; /* pass1 - count symbols */ fseek(nfile, (long)N_SYMOFF(xbuf), 0); nname = 0; for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) { fread(&nbuf, sizeof(nbuf), 1, nfile); if ( ! funcsymbol( &nbuf ) ) { continue; } nname++; } if (nname == 0) errx( 1 , "%s: no symbols" , filename ); askfor = nname + 1; nl = (nltype *) calloc( askfor , sizeof(nltype) ); - if (nl == 0) + if (nl == NULL) errx( 1 , "no room for %zu bytes of symbol table" , askfor * sizeof(nltype) ); /* pass2 - read symbols */ fseek(nfile, (long)N_SYMOFF(xbuf), 0); npe = nl; nname = 0; for (i = xbuf.a_syms; i > 0; i -= sizeof(struct nlist)) { fread(&nbuf, sizeof(nbuf), 1, nfile); if ( ! funcsymbol( &nbuf ) ) { # ifdef DEBUG if ( debug & AOUTDEBUG ) { printf( "[getsymtab] rejecting: 0x%x %s\n" , nbuf.n_type , strtab + nbuf.n_un.n_strx ); } # endif /* DEBUG */ continue; } npe->value = nbuf.n_value; npe->name = strtab+nbuf.n_un.n_strx; # ifdef DEBUG if ( debug & AOUTDEBUG ) { printf( "[getsymtab] %d %s 0x%08lx\n" , nname , npe -> name , npe -> value ); } # endif /* DEBUG */ npe++; nname++; } npe->value = -1; } /* * read in the text space of an a.out file */ static void gettextspace(FILE *nfile) { textspace = (u_char *) malloc( xbuf.a_text ); - if ( textspace == 0 ) { + if ( textspace == NULL ) { warnx("no room for %u bytes of text space: can't do -c" , xbuf.a_text ); return; } (void) fseek( nfile , N_TXTOFF( xbuf ) , 0 ); if ( fread( textspace , 1 , xbuf.a_text , nfile ) != xbuf.a_text ) { warnx("couldn't read text space: can't do -c"); free( textspace ); textspace = 0; return; } } static bool funcsymbol(struct nlist *nlistp) { char *name, c; /* * must be a text symbol, * and static text symbols don't qualify if aflag set. */ if ( ! ( ( nlistp -> n_type == ( N_TEXT | N_EXT ) ) || ( ( nlistp -> n_type == N_TEXT ) && ( aflag == 0 ) ) ) ) { return FALSE; } /* * name must start with an underscore if uflag is set. * can't have any `funny' characters in name, * where `funny' means `.' (.o file names) * need to make an exception for sparc .mul & co. * perhaps we should just drop this code entirely... */ name = strtab + nlistp -> n_un.n_strx; if ( uflag && *name != '_' ) return FALSE; #ifdef sparc if ( *name == '.' ) { char *p = name + 1; if ( *p == 'u' ) p++; if ( strcmp ( p, "mul" ) == 0 || strcmp ( p, "div" ) == 0 || strcmp ( p, "rem" ) == 0 ) return TRUE; } #endif while ( (c = *name++) ) { if ( c == '.' ) { return FALSE; } } return TRUE; } Index: head/usr.bin/gprof/arcs.c =================================================================== --- head/usr.bin/gprof/arcs.c (revision 299876) +++ head/usr.bin/gprof/arcs.c (revision 299877) @@ -1,953 +1,953 @@ /* * 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. * 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. */ #if 0 #ifndef lint static char sccsid[] = "@(#)arcs.c 8.1 (Berkeley) 6/6/93"; #endif /* not lint */ #endif #include __FBSDID("$FreeBSD$"); #include #include "gprof.h" #ifdef DEBUG int visited; int viable; int newcycle; int oldcycle; #endif /* DEBUG */ int topcmp(const void *, const void *); /* * add (or just increment) an arc */ void addarc(nltype *parentp, nltype *childp, long count) { arctype *arcp; # ifdef DEBUG if ( debug & TALLYDEBUG ) { printf( "[addarc] %ld arcs from %s to %s\n" , count , parentp -> name , childp -> name ); } # endif /* DEBUG */ arcp = arclookup( parentp , childp ); if ( arcp != 0 ) { /* * a hit: just increment the count. */ # ifdef DEBUG if ( debug & TALLYDEBUG ) { printf( "[tally] hit %ld += %ld\n" , arcp -> arc_count , count ); } # endif /* DEBUG */ arcp -> arc_count += count; return; } arcp = (arctype *)calloc( 1 , sizeof *arcp ); if (arcp == NULL) errx( 1 , "malloc failed" ); arcp -> arc_parentp = parentp; arcp -> arc_childp = childp; arcp -> arc_count = count; /* * prepend this child to the children of this parent */ arcp -> arc_childlist = parentp -> children; parentp -> children = arcp; /* * prepend this parent to the parents of this child */ arcp -> arc_parentlist = childp -> parents; childp -> parents = arcp; } /* * the code below topologically sorts the graph (collapsing cycles), * and propagates time bottom up and flags top down. */ /* * the topologically sorted name list pointers */ nltype **topsortnlp; int topcmp(const void *v1, const void *v2) { const nltype **npp1 = (const nltype **)v1; const nltype **npp2 = (const nltype **)v2; return (*npp1) -> toporder - (*npp2) -> toporder; } nltype ** doarcs(void) { nltype *parentp, **timesortnlp; arctype *arcp; long index; long pass; /* * initialize various things: * zero out child times. * count self-recursive calls. * indicate that nothing is on cycles. */ for ( parentp = nl ; parentp < npe ; parentp++ ) { parentp -> childtime = 0.0; arcp = arclookup( parentp , parentp ); if ( arcp != 0 ) { parentp -> ncall -= arcp -> arc_count; parentp -> selfcalls = arcp -> arc_count; } else { parentp -> selfcalls = 0; } parentp -> npropcall = parentp -> ncall; parentp -> propfraction = 0.0; parentp -> propself = 0.0; parentp -> propchild = 0.0; parentp -> printflag = FALSE; parentp -> toporder = DFN_NAN; parentp -> cycleno = 0; parentp -> cyclehead = parentp; parentp -> cnext = 0; } for ( pass = 1 ; ; pass++ ) { /* * topologically order things * if any node is unnumbered, * number it and any of its descendents. */ for ( dfn_init() , parentp = nl ; parentp < npe ; parentp++ ) { if ( parentp -> toporder == DFN_NAN ) { dfn( parentp ); } } /* * link together nodes on the same cycle */ cyclelink(); /* * if no cycles to break up, proceed */ if ( ! Cflag ) break; /* * analyze cycles to determine breakup */ # ifdef DEBUG if ( debug & BREAKCYCLE ) { printf("[doarcs] pass %ld, cycle(s) %d\n" , pass , ncycle ); } # endif /* DEBUG */ if ( pass == 1 ) { printf( "\n\n%s %s\n%s %d:\n" , "The following arcs were deleted" , "from the propagation calculation" , "to reduce the maximum cycle size to", cyclethreshold ); } if ( cycleanalyze() ) break; free ( cyclenl ); ncycle = 0; for ( parentp = nl ; parentp < npe ; parentp++ ) { parentp -> toporder = DFN_NAN; parentp -> cycleno = 0; parentp -> cyclehead = parentp; parentp -> cnext = 0; } } if ( pass > 1 ) { printf( "\f\n" ); } else { printf( "\tNone\n\n" ); } /* * Sort the symbol table in reverse topological order */ topsortnlp = (nltype **) calloc( nname , sizeof(nltype *) ); if ( topsortnlp == (nltype **) 0 ) errx( 1 , "[doarcs] ran out of memory for topo sorting" ); for ( index = 0 ; index < nname ; index += 1 ) { topsortnlp[ index ] = &nl[ index ]; } qsort( topsortnlp , nname , sizeof(nltype *) , topcmp ); # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[doarcs] topological sort listing\n" ); for ( index = 0 ; index < nname ; index += 1 ) { printf( "[doarcs] " ); printf( "%d:" , topsortnlp[ index ] -> toporder ); printname( topsortnlp[ index ] ); printf( "\n" ); } } # endif /* DEBUG */ /* * starting from the topological top, * propagate print flags to children. * also, calculate propagation fractions. * this happens before time propagation * since time propagation uses the fractions. */ doflags(); /* * starting from the topological bottom, * propagate children times up to parents. */ dotime(); /* * Now, sort by propself + propchild. * sorting both the regular function names * and cycle headers. */ timesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) ); if ( timesortnlp == (nltype **) 0 ) errx( 1 , "ran out of memory for sorting" ); for ( index = 0 ; index < nname ; index++ ) { timesortnlp[index] = &nl[index]; } for ( index = 1 ; index <= ncycle ; index++ ) { timesortnlp[nname+index-1] = &cyclenl[index]; } qsort( timesortnlp , nname + ncycle , sizeof(nltype *) , totalcmp ); for ( index = 0 ; index < nname + ncycle ; index++ ) { timesortnlp[ index ] -> index = index + 1; } return( timesortnlp ); } void dotime(void) { int index; cycletime(); for ( index = 0 ; index < nname ; index += 1 ) { timepropagate( topsortnlp[ index ] ); } } void timepropagate(nltype *parentp) { arctype *arcp; nltype *childp; double share; double propshare; if ( parentp -> propfraction == 0.0 ) { return; } /* * gather time from children of this parent. */ for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) { childp = arcp -> arc_childp; if ( arcp -> arc_flags & DEADARC ) { continue; } if ( arcp -> arc_count == 0 ) { continue; } if ( childp == parentp ) { continue; } if ( childp -> propfraction == 0.0 ) { continue; } if ( childp -> cyclehead != childp ) { if ( parentp -> cycleno == childp -> cycleno ) { continue; } if ( parentp -> toporder <= childp -> toporder ) { fprintf( stderr , "[propagate] toporder botches\n" ); } childp = childp -> cyclehead; } else { if ( parentp -> toporder <= childp -> toporder ) { fprintf( stderr , "[propagate] toporder botches\n" ); continue; } } if ( childp -> npropcall == 0 ) { continue; } /* * distribute time for this arc */ arcp -> arc_time = childp -> time * ( ( (double) arcp -> arc_count ) / ( (double) childp -> npropcall ) ); arcp -> arc_childtime = childp -> childtime * ( ( (double) arcp -> arc_count ) / ( (double) childp -> npropcall ) ); share = arcp -> arc_time + arcp -> arc_childtime; parentp -> childtime += share; /* * ( 1 - propfraction ) gets lost along the way */ propshare = parentp -> propfraction * share; /* * fix things for printing */ parentp -> propchild += propshare; arcp -> arc_time *= parentp -> propfraction; arcp -> arc_childtime *= parentp -> propfraction; /* * add this share to the parent's cycle header, if any. */ if ( parentp -> cyclehead != parentp ) { parentp -> cyclehead -> childtime += share; parentp -> cyclehead -> propchild += propshare; } # ifdef DEBUG if ( debug & PROPDEBUG ) { printf( "[dotime] child \t" ); printname( childp ); printf( " with %f %f %ld/%ld\n" , childp -> time , childp -> childtime , arcp -> arc_count , childp -> npropcall ); printf( "[dotime] parent\t" ); printname( parentp ); printf( "\n[dotime] share %f\n" , share ); } # endif /* DEBUG */ } } void cyclelink(void) { register nltype *nlp; register nltype *cyclenlp; int cycle; nltype *memberp; arctype *arcp; /* * Count the number of cycles, and initialize the cycle lists */ ncycle = 0; for ( nlp = nl ; nlp < npe ; nlp++ ) { /* * this is how you find unattached cycles */ if ( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) { ncycle += 1; } } /* * cyclenl is indexed by cycle number: * i.e. it is origin 1, not origin 0. */ cyclenl = (nltype *) calloc( ncycle + 1 , sizeof( nltype ) ); - if ( cyclenl == 0 ) + if ( cyclenl == NULL ) errx( 1 , "no room for %zu bytes of cycle headers" , ( ncycle + 1 ) * sizeof( nltype ) ); /* * now link cycles to true cycleheads, * number them, accumulate the data for the cycle */ cycle = 0; for ( nlp = nl ; nlp < npe ; nlp++ ) { if ( !( nlp -> cyclehead == nlp && nlp -> cnext != 0 ) ) { continue; } cycle += 1; cyclenlp = &cyclenl[cycle]; cyclenlp -> name = 0; /* the name */ cyclenlp -> value = 0; /* the pc entry point */ cyclenlp -> time = 0.0; /* ticks in this routine */ cyclenlp -> childtime = 0.0; /* cumulative ticks in children */ cyclenlp -> ncall = 0; /* how many times called */ cyclenlp -> selfcalls = 0; /* how many calls to self */ cyclenlp -> propfraction = 0.0; /* what % of time propagates */ cyclenlp -> propself = 0.0; /* how much self time propagates */ cyclenlp -> propchild = 0.0; /* how much child time propagates */ cyclenlp -> printflag = TRUE; /* should this be printed? */ cyclenlp -> index = 0; /* index in the graph list */ cyclenlp -> toporder = DFN_NAN; /* graph call chain top-sort order */ cyclenlp -> cycleno = cycle; /* internal number of cycle on */ cyclenlp -> cyclehead = cyclenlp; /* pointer to head of cycle */ cyclenlp -> cnext = nlp; /* pointer to next member of cycle */ cyclenlp -> parents = 0; /* list of caller arcs */ cyclenlp -> children = 0; /* list of callee arcs */ # ifdef DEBUG if ( debug & CYCLEDEBUG ) { printf( "[cyclelink] " ); printname( nlp ); printf( " is the head of cycle %d\n" , cycle ); } # endif /* DEBUG */ /* * link members to cycle header */ for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) { memberp -> cycleno = cycle; memberp -> cyclehead = cyclenlp; } /* * count calls from outside the cycle * and those among cycle members */ for ( memberp = nlp ; memberp ; memberp = memberp -> cnext ) { for ( arcp=memberp->parents ; arcp ; arcp=arcp->arc_parentlist ) { if ( arcp -> arc_parentp == memberp ) { continue; } if ( arcp -> arc_parentp -> cycleno == cycle ) { cyclenlp -> selfcalls += arcp -> arc_count; } else { cyclenlp -> npropcall += arcp -> arc_count; } } } } } /* * analyze cycles to determine breakup */ bool cycleanalyze(void) { arctype **cyclestack; arctype **stkp; arctype **arcpp; arctype **endlist; arctype *arcp; nltype *nlp; cltype *clp; bool ret; bool done; int size; int cycleno; /* * calculate the size of the cycle, and find nodes that * exit the cycle as they are desirable targets to cut * some of their parents */ for ( done = TRUE , cycleno = 1 ; cycleno <= ncycle ; cycleno++ ) { size = 0; for (nlp = cyclenl[ cycleno ] . cnext; nlp; nlp = nlp -> cnext) { size += 1; nlp -> parentcnt = 0; nlp -> flags &= ~HASCYCLEXIT; for ( arcp = nlp -> parents; arcp; arcp = arcp -> arc_parentlist ) { nlp -> parentcnt += 1; if ( arcp -> arc_parentp -> cycleno != cycleno ) nlp -> flags |= HASCYCLEXIT; } } if ( size <= cyclethreshold ) continue; done = FALSE; cyclestack = (arctype **) calloc( size + 1 , sizeof( arctype *) ); - if ( cyclestack == 0 ) + if ( cyclestack == NULL ) errx( 1, "no room for %zu bytes of cycle stack" , ( size + 1 ) * sizeof( arctype * ) ); # ifdef DEBUG if ( debug & BREAKCYCLE ) { printf( "[cycleanalyze] starting cycle %d of %d, size %d\n" , cycleno , ncycle , size ); } # endif /* DEBUG */ for ( nlp = cyclenl[ cycleno ] . cnext ; nlp ; nlp = nlp -> cnext ) { stkp = &cyclestack[0]; nlp -> flags |= CYCLEHEAD; ret = descend ( nlp , cyclestack , stkp ); nlp -> flags &= ~CYCLEHEAD; if ( ret == FALSE ) break; } free( cyclestack ); if ( cyclecnt > 0 ) { compresslist(); for ( clp = cyclehead ; clp ; ) { endlist = &clp -> list[ clp -> size ]; for ( arcpp = clp -> list ; arcpp < endlist ; arcpp++ ) (*arcpp) -> arc_cyclecnt--; cyclecnt--; clp = clp -> next; free( clp ); } cyclehead = 0; } } # ifdef DEBUG if ( debug & BREAKCYCLE ) { printf("%s visited %d, viable %d, newcycle %d, oldcycle %d\n", "[doarcs]" , visited , viable , newcycle , oldcycle); } # endif /* DEBUG */ return( done ); } bool descend(nltype *node, arctype **stkstart, arctype **stkp) { arctype *arcp; bool ret; for ( arcp = node -> children ; arcp ; arcp = arcp -> arc_childlist ) { # ifdef DEBUG visited++; # endif /* DEBUG */ if ( arcp -> arc_childp -> cycleno != node -> cycleno || ( arcp -> arc_childp -> flags & VISITED ) || ( arcp -> arc_flags & DEADARC ) ) continue; # ifdef DEBUG viable++; # endif /* DEBUG */ *stkp = arcp; if ( arcp -> arc_childp -> flags & CYCLEHEAD ) { if ( addcycle( stkstart , stkp ) == FALSE ) return( FALSE ); continue; } arcp -> arc_childp -> flags |= VISITED; ret = descend( arcp -> arc_childp , stkstart , stkp + 1 ); arcp -> arc_childp -> flags &= ~VISITED; if ( ret == FALSE ) return( FALSE ); } return( TRUE ); } bool addcycle(arctype **stkstart, arctype **stkend) { arctype **arcpp; arctype **stkloc; arctype **stkp; arctype **endlist; arctype *minarc; arctype *arcp; cltype *clp; int size; size = stkend - stkstart + 1; if ( size <= 1 ) return( TRUE ); for ( arcpp = stkstart , minarc = *arcpp ; arcpp <= stkend ; arcpp++ ) { if ( *arcpp > minarc ) continue; minarc = *arcpp; stkloc = arcpp; } for ( clp = cyclehead ; clp ; clp = clp -> next ) { if ( clp -> size != size ) continue; stkp = stkloc; endlist = &clp -> list[ size ]; for ( arcpp = clp -> list ; arcpp < endlist ; arcpp++ ) { if ( *stkp++ != *arcpp ) break; if ( stkp > stkend ) stkp = stkstart; } if ( arcpp == endlist ) { # ifdef DEBUG oldcycle++; # endif /* DEBUG */ return( TRUE ); } } clp = (cltype *) calloc( 1 , sizeof ( cltype ) + ( size - 1 ) * sizeof( arctype * ) ); - if ( clp == 0 ) { + if ( clp == NULL ) { warnx( "no room for %zu bytes of subcycle storage" , sizeof ( cltype ) + ( size - 1 ) * sizeof( arctype * ) ); return( FALSE ); } stkp = stkloc; endlist = &clp -> list[ size ]; for ( arcpp = clp -> list ; arcpp < endlist ; arcpp++ ) { arcp = *arcpp = *stkp++; if ( stkp > stkend ) stkp = stkstart; arcp -> arc_cyclecnt++; if ( ( arcp -> arc_flags & ONLIST ) == 0 ) { arcp -> arc_flags |= ONLIST; arcp -> arc_next = archead; archead = arcp; } } clp -> size = size; clp -> next = cyclehead; cyclehead = clp; # ifdef DEBUG newcycle++; if ( debug & SUBCYCLELIST ) { printsubcycle( clp ); } # endif /* DEBUG */ cyclecnt++; if ( cyclecnt >= CYCLEMAX ) return( FALSE ); return( TRUE ); } void compresslist(void) { cltype *clp; cltype **prev; arctype **arcpp; arctype **endlist; arctype *arcp; arctype *maxarcp; arctype *maxexitarcp; arctype *maxwithparentarcp; arctype *maxnoparentarcp; int maxexitcnt; int maxwithparentcnt; int maxnoparentcnt; # ifdef DEBUG const char *type; # endif /* DEBUG */ maxexitcnt = 0; maxwithparentcnt = 0; maxnoparentcnt = 0; for ( endlist = &archead , arcp = archead ; arcp ; ) { if ( arcp -> arc_cyclecnt == 0 ) { arcp -> arc_flags &= ~ONLIST; *endlist = arcp -> arc_next; arcp -> arc_next = 0; arcp = *endlist; continue; } if ( arcp -> arc_childp -> flags & HASCYCLEXIT ) { if ( arcp -> arc_cyclecnt > maxexitcnt || ( arcp -> arc_cyclecnt == maxexitcnt && arcp -> arc_cyclecnt < maxexitarcp -> arc_count ) ) { maxexitcnt = arcp -> arc_cyclecnt; maxexitarcp = arcp; } } else if ( arcp -> arc_childp -> parentcnt > 1 ) { if ( arcp -> arc_cyclecnt > maxwithparentcnt || ( arcp -> arc_cyclecnt == maxwithparentcnt && arcp -> arc_cyclecnt < maxwithparentarcp -> arc_count ) ) { maxwithparentcnt = arcp -> arc_cyclecnt; maxwithparentarcp = arcp; } } else { if ( arcp -> arc_cyclecnt > maxnoparentcnt || ( arcp -> arc_cyclecnt == maxnoparentcnt && arcp -> arc_cyclecnt < maxnoparentarcp -> arc_count ) ) { maxnoparentcnt = arcp -> arc_cyclecnt; maxnoparentarcp = arcp; } } endlist = &arcp -> arc_next; arcp = arcp -> arc_next; } if ( maxexitcnt > 0 ) { /* * first choice is edge leading to node with out-of-cycle parent */ maxarcp = maxexitarcp; # ifdef DEBUG type = "exit"; # endif /* DEBUG */ } else if ( maxwithparentcnt > 0 ) { /* * second choice is edge leading to node with at least one * other in-cycle parent */ maxarcp = maxwithparentarcp; # ifdef DEBUG type = "internal"; # endif /* DEBUG */ } else { /* * last choice is edge leading to node with only this arc as * a parent (as it will now be orphaned) */ maxarcp = maxnoparentarcp; # ifdef DEBUG type = "orphan"; # endif /* DEBUG */ } maxarcp -> arc_flags |= DEADARC; maxarcp -> arc_childp -> parentcnt -= 1; maxarcp -> arc_childp -> npropcall -= maxarcp -> arc_count; # ifdef DEBUG if ( debug & BREAKCYCLE ) { printf( "%s delete %s arc: %s (%ld) -> %s from %u cycle(s)\n" , "[compresslist]" , type , maxarcp -> arc_parentp -> name , maxarcp -> arc_count , maxarcp -> arc_childp -> name , maxarcp -> arc_cyclecnt ); } # endif /* DEBUG */ printf( "\t%s to %s with %ld calls\n" , maxarcp -> arc_parentp -> name , maxarcp -> arc_childp -> name , maxarcp -> arc_count ); prev = &cyclehead; for ( clp = cyclehead ; clp ; ) { endlist = &clp -> list[ clp -> size ]; for ( arcpp = clp -> list ; arcpp < endlist ; arcpp++ ) if ( (*arcpp) -> arc_flags & DEADARC ) break; if ( arcpp == endlist ) { prev = &clp -> next; clp = clp -> next; continue; } for ( arcpp = clp -> list ; arcpp < endlist ; arcpp++ ) (*arcpp) -> arc_cyclecnt--; cyclecnt--; *prev = clp -> next; clp = clp -> next; free( clp ); } } #ifdef DEBUG void printsubcycle(cltype *clp) { arctype **arcpp; arctype **endlist; arcpp = clp -> list; printf( "%s \n" , (*arcpp) -> arc_parentp -> name , (*arcpp) -> arc_parentp -> cycleno ) ; for ( endlist = &clp -> list[ clp -> size ]; arcpp < endlist ; arcpp++ ) printf( "\t(%ld) -> %s\n" , (*arcpp) -> arc_count , (*arcpp) -> arc_childp -> name ) ; } #endif /* DEBUG */ void cycletime(void) { int cycle; nltype *cyclenlp; nltype *childp; for ( cycle = 1 ; cycle <= ncycle ; cycle += 1 ) { cyclenlp = &cyclenl[ cycle ]; for ( childp = cyclenlp -> cnext ; childp ; childp = childp -> cnext ) { if ( childp -> propfraction == 0.0 ) { /* * all members have the same propfraction except those * that were excluded with -E */ continue; } cyclenlp -> time += childp -> time; } cyclenlp -> propself = cyclenlp -> propfraction * cyclenlp -> time; } } /* * in one top to bottom pass over the topologically sorted namelist * propagate: * printflag as the union of parents' printflags * propfraction as the sum of fractional parents' propfractions * and while we're here, sum time for functions. */ void doflags(void) { int index; nltype *childp; nltype *oldhead; oldhead = 0; for ( index = nname-1 ; index >= 0 ; index -= 1 ) { childp = topsortnlp[ index ]; /* * if we haven't done this function or cycle, * inherit things from parent. * this way, we are linear in the number of arcs * since we do all members of a cycle (and the cycle itself) * as we hit the first member of the cycle. */ if ( childp -> cyclehead != oldhead ) { oldhead = childp -> cyclehead; inheritflags( childp ); } # ifdef DEBUG if ( debug & PROPDEBUG ) { printf( "[doflags] " ); printname( childp ); printf( " inherits printflag %d and propfraction %f\n" , childp -> printflag , childp -> propfraction ); } # endif /* DEBUG */ if ( ! childp -> printflag ) { /* * printflag is off * it gets turned on by * being on -f list, * or there not being any -f list and not being on -e list. */ if ( onlist( flist , childp -> name ) || ( !fflag && !onlist( elist , childp -> name ) ) ) { childp -> printflag = TRUE; } } else { /* * this function has printing parents: * maybe someone wants to shut it up * by putting it on -e list. (but favor -f over -e) */ if ( ( !onlist( flist , childp -> name ) ) && onlist( elist , childp -> name ) ) { childp -> printflag = FALSE; } } if ( childp -> propfraction == 0.0 ) { /* * no parents to pass time to. * collect time from children if * its on -F list, * or there isn't any -F list and its not on -E list. */ if ( onlist( Flist , childp -> name ) || ( !Fflag && !onlist( Elist , childp -> name ) ) ) { childp -> propfraction = 1.0; } } else { /* * it has parents to pass time to, * but maybe someone wants to shut it up * by putting it on -E list. (but favor -F over -E) */ if ( !onlist( Flist , childp -> name ) && onlist( Elist , childp -> name ) ) { childp -> propfraction = 0.0; } } childp -> propself = childp -> time * childp -> propfraction; printtime += childp -> propself; # ifdef DEBUG if ( debug & PROPDEBUG ) { printf( "[doflags] " ); printname( childp ); printf( " ends up with printflag %d and propfraction %f\n" , childp -> printflag , childp -> propfraction ); printf( "time %f propself %f printtime %f\n" , childp -> time , childp -> propself , printtime ); } # endif /* DEBUG */ } } /* * check if any parent of this child * (or outside parents of this cycle) * have their print flags on and set the * print flag of the child (cycle) appropriately. * similarly, deal with propagation fractions from parents. */ void inheritflags(nltype *childp) { nltype *headp; arctype *arcp; nltype *parentp; nltype *memp; headp = childp -> cyclehead; if ( childp == headp ) { /* * just a regular child, check its parents */ childp -> printflag = FALSE; childp -> propfraction = 0.0; for (arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist) { parentp = arcp -> arc_parentp; if ( childp == parentp ) { continue; } childp -> printflag |= parentp -> printflag; /* * if the child was never actually called * (e.g. this arc is static (and all others are, too)) * no time propagates along this arc. */ if ( arcp -> arc_flags & DEADARC ) { continue; } if ( childp -> npropcall ) { childp -> propfraction += parentp -> propfraction * ( ( (double) arcp -> arc_count ) / ( (double) childp -> npropcall ) ); } } } else { /* * its a member of a cycle, look at all parents from * outside the cycle */ headp -> printflag = FALSE; headp -> propfraction = 0.0; for ( memp = headp -> cnext ; memp ; memp = memp -> cnext ) { for (arcp = memp->parents ; arcp ; arcp = arcp->arc_parentlist) { if ( arcp -> arc_parentp -> cyclehead == headp ) { continue; } parentp = arcp -> arc_parentp; headp -> printflag |= parentp -> printflag; /* * if the cycle was never actually called * (e.g. this arc is static (and all others are, too)) * no time propagates along this arc. */ if ( arcp -> arc_flags & DEADARC ) { continue; } if ( headp -> npropcall ) { headp -> propfraction += parentp -> propfraction * ( ( (double) arcp -> arc_count ) / ( (double) headp -> npropcall ) ); } } } for ( memp = headp ; memp ; memp = memp -> cnext ) { memp -> printflag = headp -> printflag; memp -> propfraction = headp -> propfraction; } } } Index: head/usr.bin/gprof/gprof.c =================================================================== --- head/usr.bin/gprof/gprof.c (revision 299876) +++ head/usr.bin/gprof/gprof.c (revision 299877) @@ -1,593 +1,593 @@ /* * 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. * 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 */ #if 0 #ifndef lint static char sccsid[] = "@(#)gprof.c 8.1 (Berkeley) 6/6/93"; #endif /* not lint */ #endif #include __FBSDID("$FreeBSD$"); #include #include #include #include #include "gprof.h" static int valcmp(const void *, const void *); static struct gmonhdr gmonhdr; static int lflag; static int Lflag; int main(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 '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 'K': 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 = (char *) malloc(strlen(a_outname)+6); strcpy(gmonname, a_outname); strcat(gmonname, ".gmon"); } /* * get information from the executable file. */ if ((Kflag && kernel_getnfile(a_outname, &defaultEs) == -1) || (!Kflag && 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(); exit(0); } /* * information from a gmon.out file is in two parts: * an array of sampling hits within pc ranges, * and the arcs. */ void getpfile(char *filename) { FILE *pfile; struct rawarc arc; pfile = openpfile(filename); readsamples(pfile); /* * the rest of the file consists of * a bunch of tuples. */ while ( fread( &arc , sizeof arc , 1 , pfile ) == 1 ) { # ifdef DEBUG if ( debug & SAMPLEDEBUG ) { printf( "[getpfile] frompc 0x%lx selfpc 0x%lx count %ld\n" , arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); } # endif /* DEBUG */ /* * add this arc */ tally( &arc ); } fclose(pfile); } FILE * openpfile(char *filename) { struct gmonhdr tmp; FILE *pfile; int size; int rate; if((pfile = fopen(filename, "r")) == NULL) err(1, "%s", filename); fread(&tmp, sizeof(struct gmonhdr), 1, pfile); if ( s_highpc != 0 && ( tmp.lpc != gmonhdr.lpc || tmp.hpc != gmonhdr.hpc || tmp.ncnt != gmonhdr.ncnt ) ) errx(1, "%s: incompatible with first gmon file", filename); 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) errx(0, "%s: profile clock rate (%d) %s (%ld) in first gmon file", filename, rate, "incompatible with clock rate", hz); if ( gmonhdr.histcounter_type == 0 ) { /* Historical case. The type was u_short (2 bytes in practice). */ histcounter_type = 16; histcounter_size = 2; } else { histcounter_type = gmonhdr.histcounter_type; histcounter_size = abs(histcounter_type) / CHAR_BIT; } s_lowpc = (unsigned long) gmonhdr.lpc; s_highpc = (unsigned long) gmonhdr.hpc; lowpc = (unsigned long)gmonhdr.lpc / HISTORICAL_SCALE_2; highpc = (unsigned long)gmonhdr.hpc / HISTORICAL_SCALE_2; sampbytes = gmonhdr.ncnt - size; nsamples = sampbytes / histcounter_size; # ifdef DEBUG if ( debug & SAMPLEDEBUG ) { printf( "[openpfile] hdr.lpc 0x%lx hdr.hpc 0x%lx hdr.ncnt %d\n", gmonhdr.lpc , gmonhdr.hpc , gmonhdr.ncnt ); printf( "[openpfile] s_lowpc 0x%lx s_highpc 0x%lx\n" , s_lowpc , s_highpc ); printf( "[openpfile] lowpc 0x%lx highpc 0x%lx\n" , lowpc , highpc ); printf( "[openpfile] sampbytes %d nsamples %d\n" , sampbytes , nsamples ); printf( "[openpfile] sample rate %ld\n" , hz ); } # endif /* DEBUG */ return(pfile); } void tally(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 %ld times\n" , parentp -> name , childp -> name , rawp -> raw_count ); } # endif /* DEBUG */ addarc( parentp , childp , rawp -> raw_count ); } /* * dump out the gmon.sum file */ void dumpsum(const char *sumfile) { register nltype *nlp; register arctype *arcp; struct rawarc arc; FILE *sfile; if ( ( sfile = fopen ( sumfile , "w" ) ) == NULL ) err( 1 , "%s" , sumfile ); /* * dump the header; use the last header read in */ if ( fwrite( &gmonhdr , sizeof gmonhdr , 1 , sfile ) != 1 ) err( 1 , "%s" , sumfile ); /* * dump the samples */ if (fwrite(samples, histcounter_size, nsamples, sfile) != nsamples) err( 1 , "%s" , sumfile ); /* * 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 ) err( 1 , "%s" , sumfile ); # ifdef DEBUG if ( debug & SAMPLEDEBUG ) { printf( "[dumpsum] frompc 0x%lx selfpc 0x%lx count %ld\n" , arc.raw_frompc , arc.raw_selfpc , arc.raw_count ); } # endif /* DEBUG */ } } fclose( sfile ); } static int valcmp(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; } void readsamples(FILE *pfile) { int i; intmax_t sample; if (samples == 0) { samples = (double *) calloc(nsamples, sizeof(double)); - if (samples == 0) + if (samples == NULL) errx(0, "no room for %d sample pc's", nsamples); } for (i = 0; i < nsamples; i++) { fread(&sample, histcounter_size, 1, pfile); if (feof(pfile)) break; switch ( histcounter_type ) { case -8: samples[i] += *(int8_t *)&sample; break; case 8: samples[i] += *(u_int8_t *)&sample; break; case -16: samples[i] += *(int16_t *)&sample; break; case 16: samples[i] += *(u_int16_t *)&sample; break; case -32: samples[i] += *(int32_t *)&sample; break; case 32: samples[i] += *(u_int32_t *)&sample; break; case -64: samples[i] += *(int64_t *)&sample; break; case 64: samples[i] += *(u_int64_t *)&sample; break; default: err(1, "unsupported histogram counter type %d", histcounter_type); } } if (i != nsamples) errx(1, "unexpected EOF after reading %d/%d samples", --i , nsamples ); } /* * 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). */ void asgnsamples(void) { register int j; double ccnt; double thetime; 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 + (unsigned long)(scale * i); pch = lowpc + (unsigned long)(scale * (i + 1)); thetime = ccnt; # ifdef DEBUG if ( debug & SAMPLEDEBUG ) { printf( "[asgnsamples] pcl 0x%lx pch 0x%lx ccnt %.0f\n" , pcl , pch , ccnt ); } # endif /* DEBUG */ totime += thetime; 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%lx->0x%lx-0x%lx) %s gets %f ticks %lu overlap\n", nl[j].value / HISTORICAL_SCALE_2, svalue0, svalue1, nl[j].name, overlap * thetime / scale, overlap); } # endif /* DEBUG */ nl[j].time += overlap * thetime / scale; } } } # ifdef DEBUG if (debug & SAMPLEDEBUG) { printf("[asgnsamples] totime %f\n", totime); } # endif /* DEBUG */ } unsigned long min(unsigned long a, unsigned long b) { if (ab) 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. */ void alignentries(void) { register struct nl *nlp; unsigned long bucket_of_entry; unsigned long bucket_of_code; for (nlp = nl; nlp < npe; nlp++) { nlp -> svalue = nlp -> value / HISTORICAL_SCALE_2; bucket_of_entry = (nlp->svalue - lowpc) / scale; bucket_of_code = (nlp->svalue + OFFSET_OF_CODE / HISTORICAL_SCALE_2 - lowpc) / scale; if (bucket_of_entry < bucket_of_code) { # ifdef DEBUG if (debug & SAMPLEDEBUG) { printf("[alignentries] pushing svalue 0x%lx to 0x%lx\n", nlp->svalue, nlp->svalue + OFFSET_OF_CODE / HISTORICAL_SCALE_2); } # endif /* DEBUG */ nlp->svalue += OFFSET_OF_CODE / HISTORICAL_SCALE_2; } } }