1: 
    2:  This table describes the call tree of the program, and was sorted by
    3:  the total amount of time spent in each function and its children.
    4: 
    5:  Each entry in this table consists of several lines.  The line with the
    6:  index number at the left hand margin lists the current function.
    7:  The lines above it list the functions that called this function,
    8:  and the lines below it list the functions this one called.
    9:  This line lists:
   10:      index      A unique number given to each element of the table.
   11:                 Index numbers are sorted numerically.
   12:                 The index number is printed next to every function name so
   13:                 it is easier to look up where the function in the table.
   14: 
   15:      % time     This is the percentage of the `total' time that was spent
   16:                 in this function and its children.  Note that due to
   17:                 different viewpoints, functions excluded by options, etc,
   18:                 these numbers will NOT add up to 100%.
   19: 
   20:      self       This is the total amount of time spent in this function.
   21: 
   22:      children   This is the total amount of time propagated into this
   23:                 function by its children.
   24: 
   25:      called     This is the number of times the function was called.
   26:                 If the function called itself recursively, the number
   27:                 only includes non-recursive calls, and is followed by
   28:                 a `+' and the number of recursive calls.
   29: 
   30:      name       The name of the current function.  The index number is
   31:                 printed after it.  If the function is a member of a
   32:                 cycle, the cycle number is printed between the
   33:                 function's name and the index number.
   34: 
   35: 
   36:  For the function's parents, the fields have the following meanings:
   37: 
   38:      self       This is the amount of time that was propagated directly
   39:                 from the function into this parent.
   40: 
   41:      children   This is the amount of time that was propagated from
   42:                 the function's children into this parent.
   43: 
   44:      called     This is the number of times this parent called the
   45:                 function `/' the total number of times the function
   46:                 was called.  Recursive calls to the function are not
   47:                 included in the number after the `/'.
   48: 
   49:      name       This is the name of the parent.  The parent's index
   50:                 number is printed after it.  If the parent is a
   51:                 member of a cycle, the cycle number is printed between
   52:                 the name and the index number.
   53: 
   54:  If the parents of the function cannot be determined, the word
   55:  `<spontaneous>' is printed in the `name' field, and all the other
   56:  fields are blank.
   57: 
   58:  For the function's children, the fields have the following meanings:
   59: 
   60:      self       This is the amount of time that was propagated directly
   61:                 from the child into the function.
   62: 
   63:      children   This is the amount of time that was propagated from the
   64:                 child's children to the function.
   65: 
   66:      called     This is the number of times the function called
   67:                 this child `/' the total number of times the child
   68:                 was called.  Recursive calls by the child are not
   69:                 listed in the number after the `/'.
   70: 
   71:      name       This is the name of the child.  The child's index
   72:                 number is printed after it.  If the child is a
   73:                 member of a cycle, the cycle number is printed
   74:                 between the name and the index number.
   75: 
   76:  If there are any cycles (circles) in the call graph, there is an
   77:  entry for the cycle-as-a-whole.  This entry shows who called the
   78:  cycle (as parents) and the members of the cycle (as children.)
   79:  The `+' recursive calls entry shows the number of function calls that
   80:  were internal to the cycle, and the calls entry for each member shows,
   81:  for that member, how many times it was called from other members of
   82:  the cycle.
   83: