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 DFN_Stack *dfn_stack = NULL;
40 int dfn_counter = DFN_NAN;
44 * Is CHILD already numbered?
47 DEFUN (is_numbered, (child), Sym * child)
49 return child->cg.top_order != DFN_NAN && child->cg.top_order != DFN_BUSY;
54 * Is CHILD already busy?
57 DEFUN (is_busy, (child), Sym * child)
59 if (child->cg.top_order == DFN_NAN)
68 * CHILD is part of a cycle. Find the top caller into this cycle
69 * that is not part of the cycle and make all functions in cycle
70 * members of that cycle (top caller == caller with smallest
71 * depth-first number).
74 DEFUN (find_cycle, (child), Sym * child)
81 for (cycle_top = dfn_depth; cycle_top > 0; --cycle_top)
83 head = dfn_stack[cycle_top].sym;
88 if (child->cg.cyc.head != child && child->cg.cyc.head == head)
95 fprintf (stderr, "[find_cycle] couldn't find head of cycle\n");
99 if (debug_level & DFNDEBUG)
101 printf ("[find_cycle] dfn_depth %d cycle_top %d ",
102 dfn_depth, cycle_top);
109 printf ("<unknown>");
114 if (cycle_top == dfn_depth)
117 * This is previous function, e.g. this calls itself. Sort of
120 * Since we are taking out self-cycles elsewhere no need for
121 * the special case, here.
124 printf ("[find_cycle] ");
131 * Glom intervening functions that aren't already glommed into
132 * this cycle. Things have been glommed when their cyclehead
133 * field points to the head of the cycle they are glommed
136 for (tail = head; tail->cg.cyc.next; tail = tail->cg.cyc.next)
138 /* void: chase down to tail of things already glommed */
140 printf ("[find_cycle] tail ");
145 * If what we think is the top of the cycle has a cyclehead
146 * field, then it's not really the head of the cycle, which is
147 * really what we want.
149 if (head->cg.cyc.head != head)
151 head = head->cg.cyc.head;
152 DBG (DFNDEBUG, printf ("[find_cycle] new cyclehead ");
156 for (index = cycle_top + 1; index <= dfn_depth; ++index)
158 child = dfn_stack[index].sym;
159 if (child->cg.cyc.head == child)
162 * Not yet glommed anywhere, glom it and fix any
163 * children it has glommed.
165 tail->cg.cyc.next = child;
166 child->cg.cyc.head = head;
167 DBG (DFNDEBUG, printf ("[find_cycle] glomming ");
172 for (tail = child; tail->cg.cyc.next; tail = tail->cg.cyc.next)
174 tail->cg.cyc.next->cg.cyc.head = head;
175 DBG (DFNDEBUG, printf ("[find_cycle] and its tail ");
176 print_name (tail->cg.cyc.next);
182 else if (child->cg.cyc.head != head /* firewall */ )
184 fprintf (stderr, "[find_cycle] glommed, but not to head\n");
193 * Prepare for visiting the children of PARENT. Push a parent onto
194 * the stack and mark it busy.
197 DEFUN (pre_visit, (parent), Sym * parent)
201 if (dfn_depth >= dfn_maxdepth)
203 dfn_maxdepth += DFN_INCR_DEPTH;
204 dfn_stack = xrealloc (dfn_stack, dfn_maxdepth * sizeof *dfn_stack);
207 dfn_stack[dfn_depth].sym = parent;
208 dfn_stack[dfn_depth].cycle_top = dfn_depth;
209 parent->cg.top_order = DFN_BUSY;
210 DBG (DFNDEBUG, printf ("[pre_visit]\t\t%d:", dfn_depth);
217 * Done with visiting node PARENT. Pop PARENT off dfn_stack
218 * and number functions if PARENT is head of a cycle.
221 DEFUN (post_visit, (parent), Sym * parent)
225 DBG (DFNDEBUG, printf ("[post_visit]\t%d: ", dfn_depth);
229 * Number functions and things in their cycles unless the function
230 * is itself part of a cycle:
232 if (parent->cg.cyc.head == parent)
235 for (member = parent; member; member = member->cg.cyc.next)
237 member->cg.top_order = dfn_counter;
238 DBG (DFNDEBUG, printf ("[post_visit]\t\tmember ");
240 printf ("-> cg.top_order = %d\n", dfn_counter));
245 DBG (DFNDEBUG, printf ("[post_visit]\t\tis part of a cycle\n"));
252 * Given this PARENT, depth first number its children.
255 DEFUN (cg_dfn, (parent), Sym * parent)
259 DBG (DFNDEBUG, printf ("[dfn] dfn( ");
263 * If we're already numbered, no need to look any further:
265 if (is_numbered (parent))
270 * If we're already busy, must be a cycle:
272 if (is_busy (parent))
279 * Recursively visit children:
281 for (arc = parent->cg.children; arc; arc = arc->next_child)