1/*
2 * Copyright (c) 1983, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if 0
31#ifndef lint
32static char sccsid[] = "@(#)dfn.c	8.1 (Berkeley) 6/6/93";
33#endif /* not lint */
34#endif
35
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: releng/10.3/usr.bin/gprof/dfn.c 246783 2013-02-14 08:16:03Z charnier $");
38
39#include <err.h>
40#include "gprof.h"
41
42#define	DFN_DEPTH	100
43struct dfnstruct {
44    nltype	*nlentryp;
45    int		cycletop;
46};
47typedef struct dfnstruct	dfntype;
48
49dfntype	dfn_stack[ DFN_DEPTH ];
50int	dfn_depth;
51
52int	dfn_counter;
53
54void
55dfn_init(void)
56{
57
58    dfn_depth = 0;
59    dfn_counter = DFN_NAN;
60}
61
62    /*
63     *	given this parent, depth first number its children.
64     */
65void
66dfn(nltype *parentp)
67{
68    arctype	*arcp;
69
70#   ifdef DEBUG
71	if ( debug & DFNDEBUG ) {
72	    printf( "[dfn] dfn(" );
73	    printname( parentp );
74	    printf( ")\n" );
75	}
76#   endif /* DEBUG */
77	/*
78	 *	if we're already numbered, no need to look any further.
79	 */
80    if ( dfn_numbered( parentp ) ) {
81	return;
82    }
83	/*
84	 *	if we're already busy, must be a cycle
85	 */
86    if ( dfn_busy( parentp ) ) {
87	dfn_findcycle( parentp );
88	return;
89    }
90	/*
91	 *	visit yourself before your children
92	 */
93    dfn_pre_visit( parentp );
94	/*
95	 *	visit children
96	 */
97    for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
98	    if ( arcp -> arc_flags & DEADARC )
99		continue;
100	    dfn( arcp -> arc_childp );
101    }
102	/*
103	 *	visit yourself after your children
104	 */
105    dfn_post_visit( parentp );
106}
107
108    /*
109     *	push a parent onto the stack and mark it busy
110     */
111void
112dfn_pre_visit(nltype *parentp)
113{
114
115    dfn_depth += 1;
116    if ( dfn_depth >= DFN_DEPTH )
117	errx( 1 , "[dfn] out of my depth (dfn_stack overflow)" );
118    dfn_stack[ dfn_depth ].nlentryp = parentp;
119    dfn_stack[ dfn_depth ].cycletop = dfn_depth;
120    parentp -> toporder = DFN_BUSY;
121#   ifdef DEBUG
122	if ( debug & DFNDEBUG ) {
123	    printf( "[dfn_pre_visit]\t\t%d:" , dfn_depth );
124	    printname( parentp );
125	    printf( "\n" );
126	}
127#   endif /* DEBUG */
128}
129
130    /*
131     *	are we already numbered?
132     */
133bool
134dfn_numbered(nltype *childp)
135{
136
137    return ( childp -> toporder != DFN_NAN && childp -> toporder != DFN_BUSY );
138}
139
140    /*
141     *	are we already busy?
142     */
143bool
144dfn_busy(nltype *childp)
145{
146
147    if ( childp -> toporder == DFN_NAN ) {
148	return FALSE;
149    }
150    return TRUE;
151}
152
153    /*
154     *	MISSING: an explanation
155     */
156void
157dfn_findcycle(nltype *childp)
158{
159    int		cycletop;
160    nltype	*cycleheadp;
161    nltype	*tailp;
162    int		index;
163
164    for ( cycletop = dfn_depth ; cycletop > 0 ; cycletop -= 1 ) {
165	cycleheadp = dfn_stack[ cycletop ].nlentryp;
166	if ( childp == cycleheadp ) {
167	    break;
168	}
169	if ( childp -> cyclehead != childp &&
170	    childp -> cyclehead == cycleheadp ) {
171	    break;
172	}
173    }
174    if ( cycletop <= 0 )
175	errx( 1 , "[dfn_findcycle] couldn't find head of cycle" );
176#   ifdef DEBUG
177	if ( debug & DFNDEBUG ) {
178	    printf( "[dfn_findcycle] dfn_depth %d cycletop %d " ,
179		    dfn_depth , cycletop  );
180	    printname( cycleheadp );
181	    printf( "\n" );
182	}
183#   endif /* DEBUG */
184    if ( cycletop == dfn_depth ) {
185	    /*
186	     *	this is previous function, e.g. this calls itself
187	     *	sort of boring
188	     */
189	dfn_self_cycle( childp );
190    } else {
191	    /*
192	     *	glom intervening functions that aren't already
193	     *	glommed into this cycle.
194	     *	things have been glommed when their cyclehead field
195	     *	points to the head of the cycle they are glommed into.
196	     */
197	for ( tailp = cycleheadp ; tailp -> cnext ; tailp = tailp -> cnext ) {
198	    /* void: chase down to tail of things already glommed */
199#	    ifdef DEBUG
200		if ( debug & DFNDEBUG ) {
201		    printf( "[dfn_findcycle] tail " );
202		    printname( tailp );
203		    printf( "\n" );
204		}
205#	    endif /* DEBUG */
206	}
207	    /*
208	     *	if what we think is the top of the cycle
209	     *	has a cyclehead field, then it's not really the
210	     *	head of the cycle, which is really what we want
211	     */
212	if ( cycleheadp -> cyclehead != cycleheadp ) {
213	    cycleheadp = cycleheadp -> cyclehead;
214#	    ifdef DEBUG
215		if ( debug & DFNDEBUG ) {
216		    printf( "[dfn_findcycle] new cyclehead " );
217		    printname( cycleheadp );
218		    printf( "\n" );
219		}
220#	    endif /* DEBUG */
221	}
222	for ( index = cycletop + 1 ; index <= dfn_depth ; index += 1 ) {
223	    childp = dfn_stack[ index ].nlentryp;
224	    if ( childp -> cyclehead == childp ) {
225		    /*
226		     *	not yet glommed anywhere, glom it
227		     *	and fix any children it has glommed
228		     */
229		tailp -> cnext = childp;
230		childp -> cyclehead = cycleheadp;
231#		ifdef DEBUG
232		    if ( debug & DFNDEBUG ) {
233			printf( "[dfn_findcycle] glomming " );
234			printname( childp );
235			printf( " onto " );
236			printname( cycleheadp );
237			printf( "\n" );
238		    }
239#		endif /* DEBUG */
240		for ( tailp = childp ; tailp->cnext ; tailp = tailp->cnext ) {
241		    tailp -> cnext -> cyclehead = cycleheadp;
242#		    ifdef DEBUG
243			if ( debug & DFNDEBUG ) {
244			    printf( "[dfn_findcycle] and its tail " );
245			    printname( tailp -> cnext );
246			    printf( " onto " );
247			    printname( cycleheadp );
248			    printf( "\n" );
249			}
250#		    endif /* DEBUG */
251		}
252	    } else if ( childp -> cyclehead != cycleheadp /* firewall */ ) {
253		fprintf( stderr ,
254			"[dfn_busy] glommed, but not to cyclehead\n" );
255	    }
256	}
257    }
258}
259
260    /*
261     *	deal with self-cycles
262     *	for lint: ARGSUSED
263     */
264void
265dfn_self_cycle(nltype *parentp)
266{
267	/*
268	 *	since we are taking out self-cycles elsewhere
269	 *	no need for the special case, here.
270	 */
271#   ifdef DEBUG
272	if ( debug & DFNDEBUG ) {
273	    printf( "[dfn_self_cycle] " );
274	    printname( parentp );
275	    printf( "\n" );
276	}
277#   endif /* DEBUG */
278}
279
280    /*
281     *	visit a node after all its children
282     *	[MISSING: an explanation]
283     *	and pop it off the stack
284     */
285void
286dfn_post_visit(nltype *parentp)
287{
288    nltype	*memberp;
289
290#   ifdef DEBUG
291	if ( debug & DFNDEBUG ) {
292	    printf( "[dfn_post_visit]\t%d: " , dfn_depth );
293	    printname( parentp );
294	    printf( "\n" );
295	}
296#   endif /* DEBUG */
297	/*
298	 *	number functions and things in their cycles
299	 *	unless the function is itself part of a cycle
300	 */
301    if ( parentp -> cyclehead == parentp ) {
302	dfn_counter += 1;
303	for ( memberp = parentp ; memberp ; memberp = memberp -> cnext ) {
304	    memberp -> toporder = dfn_counter;
305#	    ifdef DEBUG
306		if ( debug & DFNDEBUG ) {
307		    printf( "[dfn_post_visit]\t\tmember " );
308		    printname( memberp );
309		    printf( " -> toporder = %d\n" , dfn_counter );
310		}
311#	    endif /* DEBUG */
312	}
313    } else {
314#	ifdef DEBUG
315	    if ( debug & DFNDEBUG ) {
316		printf( "[dfn_post_visit]\t\tis part of a cycle\n" );
317	    }
318#	endif /* DEBUG */
319    }
320    dfn_depth -= 1;
321}
322