aboutsummaryrefslogtreecommitdiff
path: root/gmon
diff options
context:
space:
mode:
Diffstat (limited to 'gmon')
-rw-r--r--gmon/Makefile4
-rw-r--r--gmon/bb_exit_func.c156
-rw-r--r--gmon/gmon.c380
-rw-r--r--gmon/mcount.c10
-rw-r--r--gmon/sys/gmon.h25
-rw-r--r--gmon/sys/gmon_out.h132
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_ */