diff options
Diffstat (limited to 'gmon')
| -rw-r--r-- | gmon/Makefile | 4 | ||||
| -rw-r--r-- | gmon/bb_exit_func.c | 156 | ||||
| -rw-r--r-- | gmon/gmon.c | 380 | ||||
| -rw-r--r-- | gmon/mcount.c | 10 | ||||
| -rw-r--r-- | gmon/sys/gmon.h | 25 | ||||
| -rw-r--r-- | gmon/sys/gmon_out.h | 132 |
6 files changed, 534 insertions, 173 deletions
diff --git a/gmon/Makefile b/gmon/Makefile index 3c6f85d..2d4c501 100644 --- a/gmon/Makefile +++ b/gmon/Makefile @@ -21,9 +21,9 @@ # subdir := gmon -headers := sys/gmon.h +headers := sys/gmon.h sys/gmon_out.h distribute := machine-gmon.h -routines := gmon mcount profil +routines := gmon mcount profil bb_init_func bb_exit_func include ../Rules diff --git a/gmon/bb_exit_func.c b/gmon/bb_exit_func.c new file mode 100644 index 0000000..215f0ba --- /dev/null +++ b/gmon/bb_exit_func.c @@ -0,0 +1,156 @@ +/* Copyright (C) 1996 Free Software Foundation, Inc. + Contributed by David Mosberger (davidm@cs.arizona.edu). + +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* __bb_exit_func() dumps all the basic-block statistics linked into + the bb_head chain to .d files. */ + +#include <sys/gmon_out.h> +#include <sys/types.h> + +#include <ansidecl.h> +#include <stdio.h> +#include <strings.h> + +/* structure emitted by -a */ +struct bb { + long zero_word; + const char *filename; + long *counts; + long ncounts; + struct bb *next; + const unsigned long *addresses; +}; + +extern struct bb *__bb_head; /* from gmon.c */ + +#define OUT_NAME "gmon.out" + + +void +DEFUN_VOID(__bb_exit_func) +{ + const int version = GMON_VERSION; + struct gmon_hdr ghdr; + struct bb *ptr; + FILE *fp; + fp = fopen(OUT_NAME, "wb"); + if (!fp) + { + perror(OUT_NAME); + return; + } + bcopy(GMON_MAGIC, &ghdr.cookie[0], 4); + bcopy(&version, &ghdr.version, sizeof(version)); + fwrite(&ghdr, sizeof(ghdr), 1, fp); + + for (ptr = __bb_head; ptr != 0; ptr = ptr->next) { + u_int ncounts = ptr->ncounts; + u_char tag; + u_int i; + + tag = GMON_TAG_BB_COUNT; + fwrite(&tag, sizeof(tag), 1, fp); + fwrite(&ncounts, sizeof(ncounts), 1, fp); + + for (i = 0; i < ncounts; ++i) { + fwrite(&ptr->addresses[i], sizeof(ptr->addresses[0]), 1, fp); + fwrite(&ptr->counts[i], sizeof(ptr->counts[0]), 1, fp); + } + } + fclose (fp); +} +/* Copyright (C) 1996 Free Software Foundation, Inc. + Contributed by David Mosberger (davidm@cs.arizona.edu). + +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* __bb_exit_func() dumps all the basic-block statistics linked into + the bb_head chain to .d files. */ + +#include <sys/gmon_out.h> +#include <sys/types.h> + +#include <ansidecl.h> +#include <stdio.h> +#include <strings.h> + +/* structure emitted by -a */ +struct bb { + long zero_word; + const char *filename; + long *counts; + long ncounts; + struct bb *next; + const unsigned long *addresses; +}; + +extern struct bb *__bb_head; /* from gmon.c */ + +#define OUT_NAME "gmon.out" + + +void +DEFUN_VOID(__bb_exit_func) +{ + const int version = GMON_VERSION; + struct gmon_hdr ghdr; + struct bb *ptr; + FILE *fp; + fp = fopen(OUT_NAME, "wb"); + if (!fp) + { + perror(OUT_NAME); + return; + } + bcopy(GMON_MAGIC, &ghdr.cookie[0], 4); + bcopy(&version, &ghdr.version, sizeof(version)); + fwrite(&ghdr, sizeof(ghdr), 1, fp); + + for (ptr = __bb_head; ptr != 0; ptr = ptr->next) { + u_int ncounts = ptr->ncounts; + u_char tag; + u_int i; + + tag = GMON_TAG_BB_COUNT; + fwrite(&tag, sizeof(tag), 1, fp); + fwrite(&ncounts, sizeof(ncounts), 1, fp); + + for (i = 0; i < ncounts; ++i) { + fwrite(&ptr->addresses[i], sizeof(ptr->addresses[0]), 1, fp); + fwrite(&ptr->counts[i], sizeof(ptr->counts[0]), 1, fp); + } + } + fclose (fp); +} diff --git a/gmon/gmon.c b/gmon/gmon.c index 3428016..8e47c52 100644 --- a/gmon/gmon.c +++ b/gmon/gmon.c @@ -30,203 +30,261 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ - -#if !defined(lint) && defined(LIBC_SCCS) -static char sccsid[] = "@(#)gmon.c 8.1 (Berkeley) 6/4/93"; -#endif - #include <sys/param.h> #include <sys/time.h> #include <sys/gmon.h> +#include <sys/gmon_out.h> +#include <ansidecl.h> #include <stdio.h> #include <fcntl.h> +#include <unistd.h> + +#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> +struct __bb *__bb_head; /* Head of basic-block list or NULL. */ + struct gmonparam _gmonparam = { GMON_PROF_OFF }; +/* + * See profil(2) where this is described: + */ static int s_scale; -/* see profil(2) where this is describe (incorrectly) */ #define SCALE_1_TO_1 0x10000L -#define ERR(s) write(2, s, sizeof(s) - 1) +#define ERR(s) write(2, s, sizeof(s)) + +/* + * Discover the tick frequency of the machine if something goes wrong, + * we return 0, an impossible hertz. + */ +static int +DEFUN_VOID(hertz) +{ + struct itimerval tim; + + tim.it_interval.tv_sec = 0; + tim.it_interval.tv_usec = 1; + tim.it_value.tv_sec = 0; + tim.it_value.tv_usec = 0; + setitimer(ITIMER_REAL, &tim, 0); + setitimer(ITIMER_REAL, 0, &tim); + if (tim.it_interval.tv_usec < 2) + return 0; + return (1000000 / tim.it_interval.tv_usec); +} + + +/* + * Control profiling + * profiling is what mcount checks to see if + * all the data structures are ready. + */ +void +DEFUN(moncontrol, (mode), int mode) +{ + struct gmonparam *p = &_gmonparam; + + if (mode) + { + /* start */ + profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale); + p->state = GMON_PROF_ON; + } + else + { + /* stop */ + profil((void *) 0, 0, 0, 0); + p->state = GMON_PROF_OFF; + } +} -void moncontrol __P((int)); -static int hertz __P((void)); void -monstartup(lowpc, highpc) - u_long lowpc; - u_long highpc; +DEFUN(monstartup, (lowpc, highpc), u_long lowpc AND u_long highpc) { - register int o; - char *cp; - struct gmonparam *p = &_gmonparam; - - /* - * round lowpc and highpc to multiples of the density we're using - * so the rest of the scaling (here and in gprof) stays in ints. - */ - p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER)); - p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER)); - p->textsize = p->highpc - p->lowpc; - p->kcountsize = p->textsize / HISTFRACTION; - p->hashfraction = HASHFRACTION; - p->fromssize = p->textsize / HASHFRACTION; - p->tolimit = p->textsize * ARCDENSITY / 100; - if (p->tolimit < MINARCS) - p->tolimit = MINARCS; - else if (p->tolimit > MAXARCS) - p->tolimit = MAXARCS; - p->tossize = p->tolimit * sizeof(struct tostruct); - - cp = malloc (p->kcountsize + p->fromssize + p->tossize); - if (! cp) { - ERR("monstartup: out of memory\n"); - return; - } - bzero(cp, p->kcountsize + p->fromssize + p->tossize); - p->tos = (struct tostruct *)cp; - cp += p->tossize; - p->kcount = (u_short *)cp; - cp += p->kcountsize; - p->froms = (u_short *)cp; + register int o; + char *cp; + struct gmonparam *p = &_gmonparam; + + /* + * round lowpc and highpc to multiples of the density we're using + * so the rest of the scaling (here and in gprof) stays in ints. + */ + p->lowpc = ROUNDDOWN(lowpc, HISTFRACTION * sizeof(HISTCOUNTER)); + p->highpc = ROUNDUP(highpc, HISTFRACTION * sizeof(HISTCOUNTER)); + p->textsize = p->highpc - p->lowpc; + p->kcountsize = p->textsize / HISTFRACTION; + p->hashfraction = HASHFRACTION; + p->log_hashfraction = -1; + if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) { + /* if HASHFRACTION is a power of two, mcount can use shifting + instead of integer division. Precompute shift amount. */ + p->log_hashfraction = ffs(p->hashfraction * sizeof(*p->froms)) - 1; + } + p->fromssize = p->textsize / HASHFRACTION; + p->tolimit = p->textsize * ARCDENSITY / 100; + if (p->tolimit < MINARCS) + p->tolimit = MINARCS; + else if (p->tolimit > MAXARCS) + p->tolimit = MAXARCS; + p->tossize = p->tolimit * sizeof(struct tostruct); - p->tos[0].link = 0; + cp = malloc (p->kcountsize + p->fromssize + p->tossize); + if (! cp) + { + ERR("monstartup: out of memory\n"); + return; + } + bzero(cp, p->kcountsize + p->fromssize + p->tossize); + p->tos = (struct tostruct *)cp; + cp += p->tossize; + p->kcount = (u_short *)cp; + cp += p->kcountsize; + p->froms = (u_short *)cp; - o = p->highpc - p->lowpc; - if (p->kcountsize < o) { + p->tos[0].link = 0; + + o = p->highpc - p->lowpc; + if (p->kcountsize < o) + { #ifndef hp300 - s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1; -#else /* avoid floating point */ - int quot = o / p->kcountsize; - - if (quot >= 0x10000) - s_scale = 1; - else if (quot >= 0x100) - s_scale = 0x10000 / quot; - else if (o >= 0x800000) - s_scale = 0x1000000 / (o / (p->kcountsize >> 8)); - else - s_scale = 0x1000000 / ((o << 8) / p->kcountsize); + s_scale = ((float)p->kcountsize / o ) * SCALE_1_TO_1; +#else + /* avoid floating point operations */ + int quot = o / p->kcountsize; + + if (quot >= 0x10000) + s_scale = 1; + else if (quot >= 0x100) + s_scale = 0x10000 / quot; + else if (o >= 0x800000) + s_scale = 0x1000000 / (o / (p->kcountsize >> 8)); + else + s_scale = 0x1000000 / ((o << 8) / p->kcountsize); #endif - } else - s_scale = SCALE_1_TO_1; + } else + s_scale = SCALE_1_TO_1; - moncontrol(1); + moncontrol(1); } -void -_mcleanup() + +static void +DEFUN(write_hist, (fd), int fd) { - int fd; - int fromindex; - int endfrom; - u_long frompc; - int toindex; - struct rawarc rawarc; - struct gmonparam *p = &_gmonparam; - struct gmonhdr gmonhdr, *hdr; -#ifdef DEBUG - int log, len; - char buf[200]; -#endif + const u_char tag = GMON_TAG_TIME_HIST; + struct gmon_hist_hdr thdr; + int size, rate; - if (p->state == GMON_PROF_ERROR) - ERR("_mcleanup: tos overflow\n"); + if (_gmonparam.kcountsize > 0) + { + size = _gmonparam.kcountsize / sizeof(HISTCOUNTER); + rate = hertz(); + bcopy(&_gmonparam.lowpc, &thdr.low_pc, sizeof(thdr.low_pc)); + bcopy(&_gmonparam.highpc, &thdr.high_pc, sizeof(thdr.high_pc)); + bcopy(&size, &thdr.hist_size, sizeof(thdr.hist_size)); + bcopy(&rate, &thdr.prof_rate, sizeof(thdr.prof_rate)); + strcpy(thdr.dimen, "seconds"); + thdr.dimen_abbrev = 's'; - moncontrol(0); - fd = open("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666); - if (fd < 0) { - perror("mcount: gmon.out"); - return; - } -#ifdef DEBUG - log = open("gmon.log", O_CREAT|O_TRUNC|O_WRONLY, 0664); - if (log < 0) { - perror("mcount: gmon.log"); - return; - } - len = sprintf(buf, "[mcleanup1] kcount 0x%x ssiz %d\n", - p->kcount, p->kcountsize); - write(log, buf, len); -#endif - hdr = (struct gmonhdr *)&gmonhdr; - hdr->lpc = p->lowpc; - hdr->hpc = p->highpc; - hdr->ncnt = p->kcountsize + sizeof(gmonhdr); - hdr->version = GMONVERSION; - hdr->profrate = hertz(); - write(fd, (char *)hdr, sizeof *hdr); - write(fd, p->kcount, p->kcountsize); - endfrom = p->fromssize / sizeof(*p->froms); - for (fromindex = 0; fromindex < endfrom; fromindex++) { - if (p->froms[fromindex] == 0) - continue; - - frompc = p->lowpc; - frompc += fromindex * p->hashfraction * sizeof(*p->froms); - for (toindex = p->froms[fromindex]; toindex != 0; - toindex = p->tos[toindex].link) { -#ifdef DEBUG - len = sprintf(buf, - "[mcleanup2] frompc 0x%x selfpc 0x%x count %d\n" , - frompc, p->tos[toindex].selfpc, - p->tos[toindex].count); - write(log, buf, len); -#endif - rawarc.raw_frompc = frompc; - rawarc.raw_selfpc = p->tos[toindex].selfpc; - rawarc.raw_count = p->tos[toindex].count; - write(fd, &rawarc, sizeof rawarc); - } - } - close(fd); + write(fd, &tag, sizeof(tag)); + write(fd, &thdr, sizeof(thdr)); + write(fd, _gmonparam.kcount, _gmonparam.kcountsize); + } } -/* - * Control profiling - * profiling is what mcount checks to see if - * all the data structures are ready. - */ -void -moncontrol(mode) - int mode; + +static void +DEFUN(write_call_graph, (fd), int fd) { - struct gmonparam *p = &_gmonparam; - - if (mode) { - /* start */ - profil(p->kcount, p->kcountsize, (int)p->lowpc, - s_scale); - p->state = GMON_PROF_ON; - } else { - /* stop */ - profil(0, 0, 0, 0); - p->state = GMON_PROF_OFF; + const u_char tag = GMON_TAG_CG_ARC; + struct gmon_cg_arc_record raw_arc; + int from_index, to_index, from_len; + u_long frompc; + + from_len = _gmonparam.fromssize / sizeof(*_gmonparam.froms); + for (from_index = 0; from_index < from_len; ++from_index) + { + if (_gmonparam.froms[from_index] == 0) + continue; + + frompc = _gmonparam.lowpc; + frompc += (from_index * _gmonparam.hashfraction + * sizeof(*_gmonparam.froms)); + for (to_index = _gmonparam.froms[from_index]; + to_index != 0; + to_index = _gmonparam.tos[to_index].link) + { + bcopy(&frompc, &raw_arc.from_pc, sizeof(raw_arc.from_pc)); + bcopy(&_gmonparam.tos[to_index].selfpc, &raw_arc.self_pc, + sizeof(raw_arc.self_pc)); + bcopy(&_gmonparam.tos[to_index].count, &raw_arc.count, + sizeof(raw_arc.count)); + + write(fd, &tag, sizeof(tag)); + write(fd, &raw_arc, sizeof(raw_arc)); } + } } -/* - * discover the tick frequency of the machine - * if something goes wrong, we return 0, an impossible hertz. - */ -static int -hertz() + +static void +DEFUN(write_bb_counts, (fd), int fd) { - struct itimerval tim; - - tim.it_interval.tv_sec = 0; - tim.it_interval.tv_usec = 1; - tim.it_value.tv_sec = 0; - tim.it_value.tv_usec = 0; - setitimer(ITIMER_REAL, &tim, 0); - setitimer(ITIMER_REAL, 0, &tim); - if (tim.it_interval.tv_usec < 2) - return(0); - return (1000000 / tim.it_interval.tv_usec); + struct __bb *grp; + const u_char tag = GMON_TAG_BB_COUNT; + int ncounts; + int i; + + /* Write each group of basic-block info (all basic-blocks in a + compilation unit form a single group). */ + + for (grp = __bb_head; grp; grp = grp->next) + { + ncounts = grp->ncounts; + write(fd, &tag, sizeof(tag)); + write(fd, &ncounts, sizeof(ncounts)); + for (i = 0; i < ncounts; ++i) + { + write(fd, &grp->addresses[i], sizeof(grp->addresses[0])); + write(fd, &grp->counts[i], sizeof(grp->counts[0])); + } + } } +void +DEFUN_VOID(_mcleanup) +{ + const int version = GMON_VERSION; + struct gmon_hdr ghdr; + int fd; + + moncontrol(0); + fd = open("gmon.out", O_CREAT|O_TRUNC|O_WRONLY, 0666); + if (fd < 0) + { + perror("_mcleanup: gmon.out"); + return; + } + + /* write gmon.out header: */ + bcopy(GMON_MAGIC, &ghdr.cookie[0], 4); + bcopy(&version, &ghdr.version, sizeof(version)); + write(fd, &ghdr, sizeof(ghdr)); + + /* write PC histogram: */ + write_hist(fd); + + /* write call-graph: */ + write_call_graph(fd); + + /* write basic-block execution counts: */ + write_bb_counts(fd); + + close(fd); +} diff --git a/gmon/mcount.c b/gmon/mcount.c index ea60afc..4d3097f 100644 --- a/gmon/mcount.c +++ b/gmon/mcount.c @@ -34,6 +34,7 @@ #if !defined(lint) && !defined(KERNEL) && defined(LIBC_SCCS) static char sccsid[] = "@(#)mcount.c 8.1 (Berkeley) 6/4/93"; #endif + int i; #include <sys/param.h> #include <sys/gmon.h> @@ -67,6 +68,7 @@ _MCOUNT_DECL(frompc, selfpc) /* _mcount; may be static, inline, etc */ #ifdef KERNEL register int s; #endif + int i; p = &_gmonparam; /* @@ -89,7 +91,13 @@ _MCOUNT_DECL(frompc, selfpc) /* _mcount; may be static, inline, etc */ if (frompc > p->textsize) goto done; - frompcindex = &p->froms[frompc / (p->hashfraction * sizeof(*p->froms))]; + /* avoid integer divide if possible: */ + if (p->log_hashfraction >= 0) { + i = frompc >> p->log_hashfraction; + } else { + i = frompc / (p->hashfraction * sizeof(*p->froms)); + } + frompcindex = &p->froms[i]; toindex = *frompcindex; if (toindex == 0) { /* diff --git a/gmon/sys/gmon.h b/gmon/sys/gmon.h index f7af72b..8cbd6bd 100644 --- a/gmon/sys/gmon.h +++ b/gmon/sys/gmon.h @@ -39,17 +39,23 @@ #include <sys/cdefs.h> /* - * Structure prepended to gmon.out profiling data file. + * See gmon_out.h for gmon.out format. */ -struct gmonhdr { - u_long lpc; /* base pc address of sample buffer */ - u_long hpc; /* max pc address of sampled buffer */ - int ncnt; /* size of sample buffer (plus this header) */ - int version; /* version number */ - int profrate; /* profiling clock rate */ - int spare[3]; /* reserved */ + +/* structure emitted by "gcc -a". This must match struct bb in + gcc/libgcc2.c. It is OK for gcc to declare a longer structure as + long as the members below are present. */ +struct __bb +{ + long zero_word; + const char *filename; + long *counts; + long ncounts; + struct __bb *next; + const unsigned long *addresses; }; -#define GMONVERSION 0x00051879 + +extern struct __bb *__bb_head; /* * histogram counters are unsigned shorts (according to the kernel). @@ -137,6 +143,7 @@ struct gmonparam { u_long highpc; u_long textsize; u_long hashfraction; + long log_hashfraction; }; extern struct gmonparam _gmonparam; diff --git a/gmon/sys/gmon_out.h b/gmon/sys/gmon_out.h new file mode 100644 index 0000000..6eab094 --- /dev/null +++ b/gmon/sys/gmon_out.h @@ -0,0 +1,132 @@ +/* Copyright (C) 1996 Free Software Foundation, Inc. + Contributed by David Mosberger (davidm@cs.arizona.edu). + +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* This file specifies the format of gmon.out files. It should have +as few external dependencies as possible as it is going to be included +in many different programs. That is, minimize the number of #include's. + +A gmon.out file consists of a header (defined by gmon_hdr) followed by +a sequence of records. Each record starts with a one-byte tag +identifying the type of records, followed by records specific data. */ + +#ifndef _SYS_GMON_OUT_H_ +#define _SYS_GMON_OUT_H_ + +#define GMON_MAGIC "gmon" /* magic cookie */ +#define GMON_VERSION 1 /* version number */ + +/* + * Raw header as it appears on file (without padding). This header + * always comes first in gmon.out and is then followed by a series + * records defined below. + */ +struct gmon_hdr { + char cookie[4]; + char version[4]; + char spare[3 * 4]; +}; + +/* types of records in this file: */ +typedef enum { + GMON_TAG_TIME_HIST = 0, GMON_TAG_CG_ARC = 1, GMON_TAG_BB_COUNT = 2 +} GMON_Record_Tag; + +struct gmon_hist_hdr { + char low_pc[sizeof (char *)]; /* base pc address of sample buffer */ + char high_pc[sizeof (char *)]; /* max pc address of sampled buffer */ + char hist_size[4]; /* size of sample buffer */ + char prof_rate[4]; /* profiling clock rate */ + char dimen[15]; /* phys. dim., usually "seconds" */ + char dimen_abbrev; /* usually 's' for "seconds" */ +}; + +struct gmon_cg_arc_record { + char from_pc[sizeof (char *)]; /* address within caller's body */ + char self_pc[sizeof (char *)]; /* address within callee's body */ + char count[4]; /* number of arc traversals */ +}; + +#endif /* !_SYS_GMON_OUT_H_ */ +/* Copyright (C) 1996 Free Software Foundation, Inc. + Contributed by David Mosberger (davidm@cs.arizona.edu). + +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +/* This file specifies the format of gmon.out files. It should have +as few external dependencies as possible as it is going to be included +in many different programs. That is, minimize the number of #include's. + +A gmon.out file consists of a header (defined by gmon_hdr) followed by +a sequence of records. Each record starts with a one-byte tag +identifying the type of records, followed by records specific data. */ + +#ifndef _SYS_GMON_OUT_H_ +#define _SYS_GMON_OUT_H_ + +#define GMON_MAGIC "gmon" /* magic cookie */ +#define GMON_VERSION 1 /* version number */ + +/* + * Raw header as it appears on file (without padding). This header + * always comes first in gmon.out and is then followed by a series + * records defined below. + */ +struct gmon_hdr { + char cookie[4]; + char version[4]; + char spare[3 * 4]; +}; + +/* types of records in this file: */ +typedef enum { + GMON_TAG_TIME_HIST = 0, GMON_TAG_CG_ARC = 1, GMON_TAG_BB_COUNT = 2 +} GMON_Record_Tag; + +struct gmon_hist_hdr { + char low_pc[sizeof (char *)]; /* base pc address of sample buffer */ + char high_pc[sizeof (char *)]; /* max pc address of sampled buffer */ + char hist_size[4]; /* size of sample buffer */ + char prof_rate[4]; /* profiling clock rate */ + char dimen[15]; /* phys. dim., usually "seconds" */ + char dimen_abbrev; /* usually 's' for "seconds" */ +}; + +struct gmon_cg_arc_record { + char from_pc[sizeof (char *)]; /* address within caller's body */ + char self_pc[sizeof (char *)]; /* address within callee's body */ + char count[4]; /* number of arc traversals */ +}; + +#endif /* !_SYS_GMON_OUT_H_ */ |