usr.bin/gprof/dfn.c

   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$");
  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
  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
  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
 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
 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
 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
 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
 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
 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 }