Return to fsf_callg_bl.c CVS log

Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / gprof

Annotation of src/external/gpl3/binutils.old/dist/gprof/fsf_callg_bl.c, Revision 1.1.1.1

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