2 * Copyright (c) 1983 Regents of the University of California.
5 * Redistribution and use in source and binary forms are permitted
6 * provided that: (1) source distributions retain this entire copyright
7 * notice and comment, and (2) distributions including binaries display
8 * the following acknowledgement: ``This product includes software
9 * developed by the University of California, Berkeley and its contributors''
10 * in the documentation or other materials provided with the distribution
11 * and in all advertising materials mentioning features or use of this
12 * software. Neither the name of the University nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19 #include "libiberty.h"
21 #include "search_list.h"
28 #define DFN_INCR_DEPTH (128)
37 static boolean is_numbered
PARAMS ((Sym
*));
38 static boolean is_busy
PARAMS ((Sym
*));
39 static void find_cycle
PARAMS ((Sym
*));
40 static void pre_visit
PARAMS ((Sym
*));
41 static void post_visit
PARAMS ((Sym
*));
43 DFN_Stack
*dfn_stack
= NULL
;
46 int dfn_counter
= DFN_NAN
;
50 * Is CHILD already numbered?
56 return child
->cg
.top_order
!= DFN_NAN
&& child
->cg
.top_order
!= DFN_BUSY
;
61 * Is CHILD already busy?
67 if (child
->cg
.top_order
== DFN_NAN
)
76 * CHILD is part of a cycle. Find the top caller into this cycle
77 * that is not part of the cycle and make all functions in cycle
78 * members of that cycle (top caller == caller with smallest
79 * depth-first number).
90 for (cycle_top
= dfn_depth
; cycle_top
> 0; --cycle_top
)
92 head
= dfn_stack
[cycle_top
].sym
;
97 if (child
->cg
.cyc
.head
!= child
&& child
->cg
.cyc
.head
== head
)
104 fprintf (stderr
, "[find_cycle] couldn't find head of cycle\n");
108 if (debug_level
& DFNDEBUG
)
110 printf ("[find_cycle] dfn_depth %d cycle_top %d ",
111 dfn_depth
, cycle_top
);
118 printf ("<unknown>");
123 if (cycle_top
== dfn_depth
)
126 * This is previous function, e.g. this calls itself. Sort of
129 * Since we are taking out self-cycles elsewhere no need for
130 * the special case, here.
133 printf ("[find_cycle] ");
140 * Glom intervening functions that aren't already glommed into
141 * this cycle. Things have been glommed when their cyclehead
142 * field points to the head of the cycle they are glommed
145 for (tail
= head
; tail
->cg
.cyc
.next
; tail
= tail
->cg
.cyc
.next
)
147 /* void: chase down to tail of things already glommed */
149 printf ("[find_cycle] tail ");
154 * If what we think is the top of the cycle has a cyclehead
155 * field, then it's not really the head of the cycle, which is
156 * really what we want.
158 if (head
->cg
.cyc
.head
!= head
)
160 head
= head
->cg
.cyc
.head
;
161 DBG (DFNDEBUG
, printf ("[find_cycle] new cyclehead ");
165 for (index
= cycle_top
+ 1; index
<= dfn_depth
; ++index
)
167 child
= dfn_stack
[index
].sym
;
168 if (child
->cg
.cyc
.head
== child
)
171 * Not yet glommed anywhere, glom it and fix any
172 * children it has glommed.
174 tail
->cg
.cyc
.next
= child
;
175 child
->cg
.cyc
.head
= head
;
176 DBG (DFNDEBUG
, printf ("[find_cycle] glomming ");
181 for (tail
= child
; tail
->cg
.cyc
.next
; tail
= tail
->cg
.cyc
.next
)
183 tail
->cg
.cyc
.next
->cg
.cyc
.head
= head
;
184 DBG (DFNDEBUG
, printf ("[find_cycle] and its tail ");
185 print_name (tail
->cg
.cyc
.next
);
191 else if (child
->cg
.cyc
.head
!= head
/* firewall */ )
193 fprintf (stderr
, "[find_cycle] glommed, but not to head\n");
202 * Prepare for visiting the children of PARENT. Push a parent onto
203 * the stack and mark it busy.
211 if (dfn_depth
>= dfn_maxdepth
)
213 dfn_maxdepth
+= DFN_INCR_DEPTH
;
214 dfn_stack
= xrealloc (dfn_stack
, dfn_maxdepth
* sizeof *dfn_stack
);
217 dfn_stack
[dfn_depth
].sym
= parent
;
218 dfn_stack
[dfn_depth
].cycle_top
= dfn_depth
;
219 parent
->cg
.top_order
= DFN_BUSY
;
220 DBG (DFNDEBUG
, printf ("[pre_visit]\t\t%d:", dfn_depth
);
227 * Done with visiting node PARENT. Pop PARENT off dfn_stack
228 * and number functions if PARENT is head of a cycle.
236 DBG (DFNDEBUG
, printf ("[post_visit]\t%d: ", dfn_depth
);
240 * Number functions and things in their cycles unless the function
241 * is itself part of a cycle:
243 if (parent
->cg
.cyc
.head
== parent
)
246 for (member
= parent
; member
; member
= member
->cg
.cyc
.next
)
248 member
->cg
.top_order
= dfn_counter
;
249 DBG (DFNDEBUG
, printf ("[post_visit]\t\tmember ");
251 printf ("-> cg.top_order = %d\n", dfn_counter
));
256 DBG (DFNDEBUG
, printf ("[post_visit]\t\tis part of a cycle\n"));
263 * Given this PARENT, depth first number its children.
271 DBG (DFNDEBUG
, printf ("[dfn] dfn( ");
275 * If we're already numbered, no need to look any further:
277 if (is_numbered (parent
))
282 * If we're already busy, must be a cycle:
284 if (is_busy (parent
))
291 * Recursively visit children:
293 for (arc
= parent
->cg
.children
; arc
; arc
= arc
->next_child
)
This page took 0.035092 seconds and 4 git commands to generate.