/* * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in * compliance with the License. Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this * file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. * * @APPLE_LICENSE_HEADER_END@ */ /* $OpenBSD: dfn.c,v 1.2 1996/06/26 05:33:49 deraadt 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. 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. */ #include <stdio.h> #include <stdlib.h> #include "stuff/errors.h" #include "gprof.h" #define DFN_DEPTH 1000 struct dfnstruct { nltype *nlentryp; int cycletop; }; typedef struct dfnstruct dfntype; static dfntype dfn_stack[DFN_DEPTH] = { {0} }; static int dfn_depth = 0; static int dfn_counter = DFN_NAN; static void dfn_pre_visit( nltype *parentp); static enum bool dfn_numbered( nltype *childp); static enum bool dfn_busy( nltype *childp); static void dfn_findcycle( nltype *childp); static void dfn_self_cycle( nltype *parentp); static void dfn_self_cycle( nltype *parentp); static void dfn_post_visit( nltype *parentp); /* * 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 /* * 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){ dfn(arcp->arc_childp); } /* * visit yourself after your children */ dfn_post_visit(parentp); } /* * push a parent onto the stack and mark it busy */ static void dfn_pre_visit( nltype *parentp) { dfn_depth += 1; if(dfn_depth >= DFN_DEPTH){ fprintf(stderr, "[dfn] out of my depth (dfn_stack overflow)\n"); exit(1); } 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 } /* * are we already numbered? */ static enum bool dfn_numbered( nltype *childp) { return(childp->toporder != DFN_NAN && childp->toporder != DFN_BUSY); } /* * are we already busy? */ static enum bool dfn_busy( nltype *childp) { if(childp->toporder == DFN_NAN){ return(FALSE); } return(TRUE); } /* * MISSING: an explanation */ static void dfn_findcycle( nltype *childp) { int cycletop; nltype *cycleheadp; nltype *tailp; int index; cycleheadp = NULL; 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){ fatal("[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 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 } 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 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 } } else if(childp->cyclehead != cycleheadp /* firewall */ ){ fprintf(stderr, "[dfn_busy] glommed, but not to cyclehead\n"); } } } } /* * deal with self-cycles * for lint: ARGSUSED */ static void dfn_self_cycle( nltype *parentp) { /* * 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 } /* * visit a node after all its children * [MISSING: an explanation] * and pop it off the stack */ static 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 /* * 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 } } else{ #ifdef DEBUG if(debug & DFNDEBUG){ printf("[dfn_post_visit]\t\tis part of a cycle\n"); } #endif } dfn_depth -= 1; }