/* $OpenBSD: dfn.c,v 1.8 2014/03/16 18:38:30 guenther Exp $ */ /* $NetBSD: dfn.c,v 1.5 1995/04/19 07:15:56 cgd Exp $ */ /* * 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. 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. */ #include <stdio.h> #include "gprof.h" #define DFN_DEPTH 100 struct dfnstruct { nltype *nlentryp; int cycletop; }; typedef struct dfnstruct dfntype; dfntype dfn_stack[ DFN_DEPTH ]; int dfn_depth; int dfn_counter; void dfn_init() { dfn_depth = 0; dfn_counter = DFN_NAN; } /* * given this parent, depth first number its children. */ void dfn(nltype *parentp) { arctype *arcp; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn] dfn(" ); printname( parentp ); printf( ")\n" ); } # endif /* DEBUG */ /* * if we're already numbered, no need to look any furthur. */ if ( dfn_numbered( parentp ) ) { return; } /* * if we're already busy, must be a cycle */ if ( dfn_busy( parentp ) ) { dfn_findcycle( parentp ); return; } /* * visit yourself before your children */ dfn_pre_visit( parentp ); /* * visit children */ for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) { if ( arcp -> arc_flags & DEADARC ) continue; dfn( arcp -> arc_childp ); } /* * visit yourself after your children */ dfn_post_visit( parentp ); } /* * push a parent onto the stack and mark it busy */ void dfn_pre_visit(nltype *parentp) { dfn_depth += 1; if ( dfn_depth >= DFN_DEPTH ) errx(1, "[dfn] out of my depth (dfn_stack overflow)" ); dfn_stack[ dfn_depth ].nlentryp = parentp; dfn_stack[ dfn_depth ].cycletop = dfn_depth; parentp -> toporder = DFN_BUSY; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_pre_visit]\t\t%d:" , dfn_depth ); printname( parentp ); printf( "\n" ); } # endif /* DEBUG */ } /* * are we already numbered? */ bool dfn_numbered(nltype *childp) { return ( childp -> toporder != DFN_NAN && childp -> toporder != DFN_BUSY ); } /* * are we already busy? */ bool dfn_busy(nltype *childp) { if ( childp -> toporder == DFN_NAN ) { return FALSE; } return TRUE; } /* * MISSING: an explanation */ void dfn_findcycle(nltype *childp) { int cycletop; nltype *cycleheadp; nltype *tailp; int index; for ( cycletop = dfn_depth ; cycletop > 0 ; cycletop -= 1 ) { cycleheadp = dfn_stack[ cycletop ].nlentryp; if ( childp == cycleheadp ) { break; } if ( childp -> cyclehead != childp && childp -> cyclehead == cycleheadp ) { break; } } if ( cycletop <= 0 ) errx( 1, "[dfn_findcycle] couldn't find head of cycle"); # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_findcycle] dfn_depth %d cycletop %d " , dfn_depth , cycletop ); printname( cycleheadp ); printf( "\n" ); } # endif /* DEBUG */ if ( cycletop == dfn_depth ) { /* * this is previous function, e.g. this calls itself * sort of boring */ dfn_self_cycle( childp ); } else { /* * glom intervening functions that aren't already * glommed into this cycle. * things have been glommed when their cyclehead field * points to the head of the cycle they are glommed into. */ for ( tailp = cycleheadp ; tailp -> cnext ; tailp = tailp -> cnext ) { /* void: chase down to tail of things already glommed */ # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_findcycle] tail " ); printname( tailp ); printf( "\n" ); } # endif /* DEBUG */ } /* * if what we think is the top of the cycle * has a cyclehead field, then it's not really the * head of the cycle, which is really what we want */ if ( cycleheadp -> cyclehead != cycleheadp ) { cycleheadp = cycleheadp -> cyclehead; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_findcycle] new cyclehead " ); printname( cycleheadp ); printf( "\n" ); } # endif /* DEBUG */ } for ( index = cycletop + 1 ; index <= dfn_depth ; index += 1 ) { childp = dfn_stack[ index ].nlentryp; if ( childp -> cyclehead == childp ) { /* * not yet glommed anywhere, glom it * and fix any children it has glommed */ tailp -> cnext = childp; childp -> cyclehead = cycleheadp; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_findcycle] glomming " ); printname( childp ); printf( " onto " ); printname( cycleheadp ); printf( "\n" ); } # endif /* DEBUG */ for ( tailp = childp ; tailp->cnext ; tailp = tailp->cnext ) { tailp -> cnext -> cyclehead = cycleheadp; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_findcycle] and its tail " ); printname( tailp -> cnext ); printf( " onto " ); printname( cycleheadp ); printf( "\n" ); } # endif /* DEBUG */ } } else if ( childp -> cyclehead != cycleheadp /* firewall */ ) warnx("[dfn_busy] glommed, but not to cyclehead"); } } } /* * deal with self-cycles */ void dfn_self_cycle(nltype *parentp __unused) { /* * since we are taking out self-cycles elsewhere * no need for the special case, here. */ # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_self_cycle] " ); printname( parentp ); printf( "\n" ); } # endif /* DEBUG */ } /* * visit a node after all its children * [MISSING: an explanation] * and pop it off the stack */ void dfn_post_visit(nltype *parentp) { nltype *memberp; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_post_visit]\t%d: " , dfn_depth ); printname( parentp ); printf( "\n" ); } # endif /* DEBUG */ /* * number functions and things in their cycles * unless the function is itself part of a cycle */ if ( parentp -> cyclehead == parentp ) { dfn_counter += 1; for ( memberp = parentp ; memberp ; memberp = memberp -> cnext ) { memberp -> toporder = dfn_counter; # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_post_visit]\t\tmember " ); printname( memberp ); printf( " -> toporder = %d\n" , dfn_counter ); } # endif /* DEBUG */ } } else { # ifdef DEBUG if ( debug & DFNDEBUG ) { printf( "[dfn_post_visit]\t\tis part of a cycle\n" ); } # endif /* DEBUG */ } dfn_depth -= 1; }