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
32 static 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: stable/10/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
43 struct dfnstruct {
44 nltype *nlentryp;
45 int cycletop;
46 };
47 typedef struct dfnstruct dfntype;
48
49 dfntype dfn_stack[ DFN_DEPTH ];
50 int dfn_depth;
51
52 int dfn_counter;
53
54 void
dfn_init(void)55 dfn_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 */
65 void
dfn(nltype * parentp)66 dfn(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 */
111 void
dfn_pre_visit(nltype * parentp)112 dfn_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 */
133 bool
dfn_numbered(nltype * childp)134 dfn_numbered(nltype *childp)
135 {
136
137 return ( childp -> toporder != DFN_NAN && childp -> toporder != DFN_BUSY );
138 }
139
140 /*
141 * are we already busy?
142 */
143 bool
dfn_busy(nltype * childp)144 dfn_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 */
156 void
dfn_findcycle(nltype * childp)157 dfn_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 */
264 void
dfn_self_cycle(nltype * parentp)265 dfn_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 */
285 void
dfn_post_visit(nltype * parentp)286 dfn_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