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