usr/src/usr.bin/gprof/gprof.h

/*
 * Copyright (c) 1983, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * %sccs.include.redist.c%
 *
 *      @(#)gprof.h     8.1 (Berkeley) %G%
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/gmon.h>

#include <a.out.h>
#include <stdio.h>
#include <stdlib.h>

#if vax
#   include "vax.h"
#endif
#if sparc
#   include "sparc.h"
#endif
#if tahoe
#   include "tahoe.h"
#endif
#if hp300
#   include "hp300.h"
#endif
#if luna68k
#   include "luna68k.h"
#endif
#if i386
#   include "i386.h"
#endif
#if mips
#   include "mips.h"
#endif


    /*
     *  who am i, for error messages.
     */
char    *whoami;

    /*
     * booleans
     */
typedef int     bool;
#define FALSE   0
#define TRUE    1

    /*
     *  ticks per second
     */
long    hz;

typedef u_short UNIT;           /* unit of profiling */
char    *a_outname;
#define A_OUTNAME               "a.out"

char    *gmonname;
#define GMONNAME                "gmon.out"
#define GMONSUM                 "gmon.sum"

    /*
     *  a constructed arc,
     *      with pointers to the namelist entry of the parent and the child,
     *      a count of how many times this arc was traversed,
     *      and pointers to the next parent of this child and
     *          the next child of this parent.
     */
struct arcstruct {
    struct nl           *arc_parentp;   /* pointer to parent's nl entry */
    struct nl           *arc_childp;    /* pointer to child's nl entry */
    long                arc_count;      /* num calls from parent to child */
    double              arc_time;       /* time inherited along arc */
    double              arc_childtime;  /* childtime inherited along arc */
    struct arcstruct    *arc_parentlist; /* parents-of-this-child list */
    struct arcstruct    *arc_childlist; /* children-of-this-parent list */
    struct arcstruct    *arc_next;      /* list of arcs on cycle */
    unsigned short      arc_cyclecnt;   /* num cycles involved in */
    unsigned short      arc_flags;      /* see below */
};
typedef struct arcstruct        arctype;

    /*
     * arc flags
     */
#define DEADARC 0x01    /* time should not propagate across the arc */
#define ONLIST  0x02    /* arc is on list of arcs in cycles */

    /*
     * The symbol table;
     * for each external in the specified file we gather
     * its address, the number of calls and compute its share of cpu time.
     */
struct nl {
    char                *name;          /* the name */
    unsigned long       value;          /* the pc entry point */
    unsigned long       svalue;         /* entry point aligned to histograms */
    double              time;           /* ticks in this routine */
    double              childtime;      /* cumulative ticks in children */
    long                ncall;          /* how many times called */
    long                npropcall;      /* times called by live arcs */
    long                selfcalls;      /* how many calls to self */
    double              propfraction;   /* what % of time propagates */
    double              propself;       /* how much self time propagates */
    double              propchild;      /* how much child time propagates */
    short               printflag;      /* should this be printed? */
    short               flags;          /* see below */
    int                 index;          /* index in the graph list */
    int                 toporder;       /* graph call chain top-sort order */
    int                 cycleno;        /* internal number of cycle on */
    int                 parentcnt;      /* number of live parent arcs */
    struct nl           *cyclehead;     /* pointer to head of cycle */
    struct nl           *cnext;         /* pointer to next member of cycle */
    arctype             *parents;       /* list of caller arcs */
    arctype             *children;      /* list of callee arcs */
};
typedef struct nl       nltype;

nltype  *nl;                    /* the whole namelist */
nltype  *npe;                   /* the virtual end of the namelist */
int     nname;                  /* the number of function names */

#define HASCYCLEXIT     0x08    /* node has arc exiting from cycle */
#define CYCLEHEAD       0x10    /* node marked as head of a cycle */
#define VISITED         0x20    /* node visited during a cycle */

    /*
     * The cycle list.
     * for each subcycle within an identified cycle, we gather
     * its size and the list of included arcs.
     */
struct cl {
    int         size;           /* length of cycle */
    struct cl   *next;          /* next member of list */
    arctype     *list[1];       /* list of arcs in cycle */
    /* actually longer */
};
typedef struct cl cltype;

arctype *archead;               /* the head of arcs in current cycle list */
cltype  *cyclehead;             /* the head of the list */
int     cyclecnt;               /* the number of cycles found */
#define CYCLEMAX        100     /* maximum cycles before cutting one of them */

    /*
     *  flag which marks a nl entry as topologically ``busy''
     *  flag which marks a nl entry as topologically ``not_numbered''
     */
#define DFN_BUSY        -1
#define DFN_NAN         0

    /*
     *  namelist entries for cycle headers.
     *  the number of discovered cycles.
     */
nltype  *cyclenl;               /* cycle header namelist */
int     ncycle;                 /* number of cycles discovered */

    /*
     * The header on the gmon.out file.
     * gmon.out consists of a struct phdr (defined in gmon.h)
     * and then an array of ncnt samples representing the
     * discretized program counter values.
     *
     *  Backward compatible old style header
     */
struct ophdr {
    UNIT        *lpc;
    UNIT        *hpc;
    int         ncnt;
};

int     debug;

    /*
     * Each discretized pc sample has
     * a count of the number of samples in its range
     */
UNIT    *samples;

unsigned long   s_lowpc;        /* lowpc from the profile file */
unsigned long   s_highpc;       /* highpc from the profile file */
unsigned lowpc, highpc;         /* range profiled, in UNIT's */
unsigned sampbytes;             /* number of bytes of samples */
int     nsamples;               /* number of samples */
double  actime;                 /* accumulated time thus far for putprofline */
double  totime;                 /* total time for all routines */
double  printtime;              /* total of time being printed */
double  scale;                  /* scale factor converting samples to pc
                                   values: each sample covers scale bytes */
char    *strtab;                /* string table in core */
long    ssiz;                   /* size of the string table */
struct  exec xbuf;              /* exec header of a.out */
unsigned char   *textspace;     /* text space of a.out in core */
int     cyclethreshold;         /* with -C, minimum cycle size to ignore */

    /*
     *  option flags, from a to z.
     */
bool    aflag;                          /* suppress static functions */
bool    bflag;                          /* blurbs, too */
bool    cflag;                          /* discovered call graph, too */
bool    Cflag;                          /* find cut-set to eliminate cycles */
bool    dflag;                          /* debugging options */
bool    eflag;                          /* specific functions excluded */
bool    Eflag;                          /* functions excluded with time */
bool    fflag;                          /* specific functions requested */
bool    Fflag;                          /* functions requested with time */
bool    kflag;                          /* arcs to be deleted */
bool    sflag;                          /* sum multiple gmon.out files */
bool    zflag;                          /* zero time/called functions, too */

    /*
     *  structure for various string lists
     */
struct stringlist {
    struct stringlist   *next;
    char                *string;
};
struct stringlist       *elist;
struct stringlist       *Elist;
struct stringlist       *flist;
struct stringlist       *Flist;
struct stringlist       *kfromlist;
struct stringlist       *ktolist;

    /*
     *  function declarations
     */
/*
                addarc();
*/
int             arccmp();
arctype         *arclookup();
/*
                asgnsamples();
                printblurb();
                cyclelink();
                dfn();
*/
bool            dfn_busy();
/*
                dfn_findcycle();
*/
bool            dfn_numbered();
/*
                dfn_post_visit();
                dfn_pre_visit();
                dfn_self_cycle();
*/
nltype          **doarcs();
/*
                done();
                findcalls();
                flatprofheader();
                flatprofline();
*/
bool            funcsymbol();
/*
                getnfile();
                getpfile();
                getstrtab();
                getsymtab();
                gettextspace();
                gprofheader();
                gprofline();
                main();
*/
unsigned long   max();
int             membercmp();
unsigned long   min();
nltype          *nllookup();
FILE            *openpfile();
long            operandlength();
operandenum     operandmode();
char            *operandname();
/*
                printchildren();
                printcycle();
                printgprof();
                printmembers();
                printname();
                printparents();
                printprof();
                readsamples();
*/
unsigned long   reladdr();
/*
                sortchildren();
                sortmembers();
                sortparents();
                tally();
                timecmp();
                topcmp();
*/
int             totalcmp();
/*
                valcmp();
*/

#define LESSTHAN        -1
#define EQUALTO         0
#define GREATERTHAN     1

#define DFNDEBUG        1
#define CYCLEDEBUG      2
#define ARCDEBUG        4
#define TALLYDEBUG      8
#define TIMEDEBUG       16
#define SAMPLEDEBUG     32
#define AOUTDEBUG       64
#define CALLDEBUG       128
#define LOOKUPDEBUG     256
#define PROPDEBUG       512
#define BREAKCYCLE      1024
#define SUBCYCLELIST    2048
#define ANYDEBUG        4096