diff options
Diffstat (limited to 'libc/sysdeps/linux/common')
| -rw-r--r-- | libc/sysdeps/linux/common/.cvsignore | 1 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/Makefile | 6 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/bits/atomicity.h | 54 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/bits/machine-gmon.h | 54 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/bits/profil-counter.h | 27 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/bits/sigcontextinfo.h | 27 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/bits/stackinfo.h | 34 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/gmon-start.c | 58 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/gmon.c | 641 | ||||
| -rw-r--r-- | libc/sysdeps/linux/common/initfini.c | 5 |
10 files changed, 906 insertions, 1 deletions
diff --git a/libc/sysdeps/linux/common/.cvsignore b/libc/sysdeps/linux/common/.cvsignore index f8fa8225d..0232d6900 100644 --- a/libc/sysdeps/linux/common/.cvsignore +++ b/libc/sysdeps/linux/common/.cvsignore @@ -1,3 +1,4 @@ crti.S crtn.S initfini.S +gmon-start.S diff --git a/libc/sysdeps/linux/common/Makefile b/libc/sysdeps/linux/common/Makefile index 5b9717f2b..d51fc4281 100644 --- a/libc/sysdeps/linux/common/Makefile +++ b/libc/sysdeps/linux/common/Makefile @@ -29,6 +29,9 @@ CSRC= waitpid.c getdnnm.c gethstnm.c getcwd.c ptrace.c \ ifneq ($(strip $(EXCLUDE_BRK)),y) CSRC+=sbrk.c endif +ifeq ($(strip $(UCLIBC_PROFILING)),y) +CSRC+=gmon.c +endif COBJS=$(patsubst %.c,%.o, $(CSRC)) MSRC=syscalls.c @@ -44,6 +47,9 @@ SAFECFLAGS := $(subst -g,,$(SAFECFLAGS)) ifeq ($(strip $(DOPIC)),y) SAFECFLAGS+=-fPIC endif +ifeq ($(strip $(UCLIBC_PROFILING)),y) +SAFECFLAGS+=-DGMON_SUPPORT +endif OBJ=$(COBJS) $(MOBJ) diff --git a/libc/sysdeps/linux/common/bits/atomicity.h b/libc/sysdeps/linux/common/bits/atomicity.h new file mode 100644 index 000000000..1a756498b --- /dev/null +++ b/libc/sysdeps/linux/common/bits/atomicity.h @@ -0,0 +1,54 @@ +/* Low-level functions for atomic operations. Stub version. + Copyright (C) 1997,2001 Free Software Foundation, Inc. + 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 Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#ifndef _ATOMICITY_H +#define _ATOMICITY_H 1 + +#include <inttypes.h> + +#warning stub atomicity functions are not really atomic + +static inline int +__attribute__ ((unused)) +exchange_and_add (volatile uint32_t *mem, int val) +{ + int result = *mem; + *mem += val; + return result; +} + +static inline void +__attribute__ ((unused)) +atomic_add (volatile uint32_t *mem, int val) +{ + *mem += val; +} + +static inline int +__attribute__ ((unused)) +compare_and_swap (volatile long int *p, long int oldval, long int newval) +{ + if (*p != oldval) + return 0; + + *p = newval; + return 1; +} + +#endif /* atomicity.h */ diff --git a/libc/sysdeps/linux/common/bits/machine-gmon.h b/libc/sysdeps/linux/common/bits/machine-gmon.h new file mode 100644 index 000000000..eb046b068 --- /dev/null +++ b/libc/sysdeps/linux/common/bits/machine-gmon.h @@ -0,0 +1,54 @@ +/* Machine-dependent definitions for profiling support. Generic GCC 2 version. + Copyright (C) 1996, 1997, 2000 Free Software Foundation, Inc. + 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 Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* GCC version 2 gives us a perfect magical function to get + just the information we need: + void *__builtin_return_address (unsigned int N) + returns the return address of the frame N frames up. */ + +/* Be warned that GCC cannot usefully compile __builtin_return_address(N) + for N != 0 on all machines. In this case, you may have to write + your own version of _mcount(). */ + +#if __GNUC__ < 2 + #error "This file uses __builtin_return_address, a GCC 2 extension." +#endif + +#include <sysdep.h> +#ifndef NO_UNDERSCORES +/* The asm symbols for C functions are `_function'. + The canonical name for the counter function is `mcount', no _. */ +void _mcount (void) asm ("mcount"); +#else +/* The canonical name for the function is `_mcount' in both C and asm, + but some old asm code might assume it's `mcount'. */ +void _mcount (void); +weak_alias (_mcount, mcount) +#endif + +static void mcount_internal (u_long frompc, u_long selfpc); + +#define _MCOUNT_DECL(frompc, selfpc) \ +static inline void mcount_internal (u_long frompc, u_long selfpc) + +#define MCOUNT \ +void _mcount (void) \ +{ \ + mcount_internal ((u_long) RETURN_ADDRESS (1), (u_long) RETURN_ADDRESS (0)); \ +} diff --git a/libc/sysdeps/linux/common/bits/profil-counter.h b/libc/sysdeps/linux/common/bits/profil-counter.h new file mode 100644 index 000000000..9cae5840d --- /dev/null +++ b/libc/sysdeps/linux/common/bits/profil-counter.h @@ -0,0 +1,27 @@ +/* Machine-dependent SIGPROF signal handler. "Generic" version w/ sigcontext + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + 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 Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* In many Unix systems signal handlers are called like this + and the interrupted PC is easily findable in the `struct sigcontext'. */ + +static void +profil_counter (int signr, int code, struct sigcontext *scp) +{ + profil_count ((void *) scp->sc_pc); +} diff --git a/libc/sysdeps/linux/common/bits/sigcontextinfo.h b/libc/sysdeps/linux/common/bits/sigcontextinfo.h new file mode 100644 index 000000000..40305b488 --- /dev/null +++ b/libc/sysdeps/linux/common/bits/sigcontextinfo.h @@ -0,0 +1,27 @@ +/* Copyright (C) 1998, 1999 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* In general we cannot provide any information. */ +#define SIGCONTEXT struct sigcontext * +#define SIGCONTEXT_EXTRA_ARGS +#define GET_PC(ctx) ((void *) 0) +#define GET_FRAME(ctx) ((void *) 0) +#define GET_STACK(ctx) ((void *) 0) +#define CALL_SIGHANDLER(handler, signo, ctx) \ + (handler)((signo), SIGCONTEXT_EXTRA_ARGS (ctx)) diff --git a/libc/sysdeps/linux/common/bits/stackinfo.h b/libc/sysdeps/linux/common/bits/stackinfo.h new file mode 100644 index 000000000..1ed7b9503 --- /dev/null +++ b/libc/sysdeps/linux/common/bits/stackinfo.h @@ -0,0 +1,34 @@ +/* Copyright (C) 1999 Free Software Foundation, Inc. + 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 Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +/* This file contains a bit of information about the stack allocation + of the processor. Since there is no general truth we can't say + anything here. */ + +#ifndef _STACKINFO_H +#define _STACKINFO_H 1 + +#error Machine stack direction unknown. +#if 0 +#define _STACK_GROWS_DOWN 1 +#define _STACK_GROWS_UP 1 +#endif + +#endif /* stackinfo.h */ + + diff --git a/libc/sysdeps/linux/common/gmon-start.c b/libc/sysdeps/linux/common/gmon-start.c new file mode 100644 index 000000000..6878a7a71 --- /dev/null +++ b/libc/sysdeps/linux/common/gmon-start.c @@ -0,0 +1,58 @@ +/* Code to enable profiling at program startup. + Copyright (C) 1995,1996,1997,2000,2001,2002 Free Software Foundation, Inc. + 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 Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include <features.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/gmon.h> + +#ifdef __UCLIBC_PROFILING__ + +/* Beginning and end of our code segment. We cannot declare them + as the external functions since we want the addresses of those + labels. Taking the address of a function may have different + meanings on different platforms. */ + +extern void _start; +extern void etext; + + +void __gmon_start__ (void) +{ +#ifdef __UCLIBC_CTOR_DTOR__ + /* Protect from being called more than once. Since crti.o is linked + into every shared library, each of their init functions will call us. */ + static int called; + + if (called) + return; + + called = 1; +#endif + + /* Start keeping profiling records. */ + monstartup ((u_long) &_start, (u_long) &etext); + + /* Call _mcleanup before exiting; it will write out gmon.out from the + collected data. */ + atexit (&_mcleanup); +} +#endif + diff --git a/libc/sysdeps/linux/common/gmon.c b/libc/sysdeps/linux/common/gmon.c new file mode 100644 index 000000000..b3fe788f7 --- /dev/null +++ b/libc/sysdeps/linux/common/gmon.c @@ -0,0 +1,641 @@ +/*- + * Copyright (c) 1983, 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include <features.h> +#include <sys/param.h> +#include <sys/time.h> +#include <sys/gmon.h> +#include <sys/gmon_out.h> +#include <sys/uio.h> + +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> +#include <unistd.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <signal.h> +#include <sys/time.h> +#include <sys/types.h> + +#ifdef __UCLIBC_PROFILING__ + +/* Head of basic-block list or NULL. */ +struct __bb *__bb_head; + +struct gmonparam _gmonparam = { GMON_PROF_OFF }; + +/* + * See profil(2) where this is described: + */ +static int s_scale; +#define SCALE_1_TO_1 0x10000L + +#define ERR(s) write (STDERR_FILENO, s, sizeof (s) - 1) + +void moncontrol __P ((int mode)); +static void write_hist __P ((int fd)); +static void write_call_graph __P ((int fd)); +static void write_bb_counts __P ((int fd)); + +/* + * Control profiling + * profiling is what mcount checks to see if + * all the data structures are ready. + */ +void moncontrol (int mode) +{ + struct gmonparam *p = &_gmonparam; + + /* Don't change the state if we ran into an error. */ + if (p->state == GMON_PROF_ERROR) + return; + + if (mode) + { + /* start */ + profil((void *) p->kcount, p->kcountsize, p->lowpc, s_scale); + p->state = GMON_PROF_ON; + } + else + { + /* stop */ + profil(NULL, 0, 0, 0); + p->state = GMON_PROF_OFF; + } +} + + +void monstartup (u_long lowpc, 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->log_hashfraction = -1; + /* The following test must be kept in sync with the corresponding + test in mcount.c. */ + 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); + + cp = calloc (p->kcountsize + p->fromssize + p->tossize, 1); + if (! cp) + { + ERR("monstartup: out of memory\n"); + p->tos = NULL; + p->state = GMON_PROF_ERROR; + return; + } + p->tos = (struct tostruct *)cp; + cp += p->tossize; + p->kcount = (HISTCOUNTER *)cp; + cp += p->kcountsize; + p->froms = (ARCINDEX *)cp; + + p->tos[0].link = 0; + + o = p->highpc - p->lowpc; + if (p->kcountsize < (u_long) o) + { +#ifndef hp300 + 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; + + moncontrol(1); +} + + +/* Return frequency of ticks reported by profil. */ +static int profile_frequency (void) +{ + /* + * Discover the tick frequency of the machine if something goes wrong, + * we return 0, an impossible 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); +} + + +static void write_hist (int fd) +{ + u_char tag = GMON_TAG_TIME_HIST; + struct gmon_hist_hdr thdr __attribute__ ((aligned (__alignof__ (char *)))); + + if (_gmonparam.kcountsize > 0) + { + struct iovec iov[3] = + { + { &tag, sizeof (tag) }, + { &thdr, sizeof (struct gmon_hist_hdr) }, + { _gmonparam.kcount, _gmonparam.kcountsize } + }; + + *(char **) thdr.low_pc = (char *) _gmonparam.lowpc; + *(char **) thdr.high_pc = (char *) _gmonparam.highpc; + *(int32_t *) thdr.hist_size = (_gmonparam.kcountsize + / sizeof (HISTCOUNTER)); + *(int32_t *) thdr.prof_rate = profile_frequency (); + strncpy (thdr.dimen, "seconds", sizeof (thdr.dimen)); + thdr.dimen_abbrev = 's'; + + writev (fd, iov, 3); + } +} + + +static void write_call_graph (int fd) +{ +#define NARCS_PER_WRITEV 32 + u_char tag = GMON_TAG_CG_ARC; + struct gmon_cg_arc_record raw_arc[NARCS_PER_WRITEV] + __attribute__ ((aligned (__alignof__ (char*)))); + ARCINDEX from_index, to_index; + int from_len; + u_long frompc; + struct iovec iov[2 * NARCS_PER_WRITEV]; + int nfilled; + + for (nfilled = 0; nfilled < NARCS_PER_WRITEV; ++nfilled) + { + iov[2 * nfilled].iov_base = &tag; + iov[2 * nfilled].iov_len = sizeof (tag); + + iov[2 * nfilled + 1].iov_base = &raw_arc[nfilled]; + iov[2 * nfilled + 1].iov_len = sizeof (struct gmon_cg_arc_record); + } + + nfilled = 0; + 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) + { + struct arc + { + char *frompc; + char *selfpc; + int32_t count; + } + arc; + + arc.frompc = (char *) frompc; + arc.selfpc = (char *) _gmonparam.tos[to_index].selfpc; + arc.count = _gmonparam.tos[to_index].count; + memcpy (raw_arc + nfilled, &arc, sizeof (raw_arc [0])); + + if (++nfilled == NARCS_PER_WRITEV) + { + writev (fd, iov, 2 * nfilled); + nfilled = 0; + } + } + } + if (nfilled > 0) + writev (fd, iov, 2 * nfilled); +} + + +static void write_bb_counts (int fd) +{ + struct __bb *grp; + u_char tag = GMON_TAG_BB_COUNT; + size_t ncounts; + size_t i; + + struct iovec bbhead[2] = + { + { &tag, sizeof (tag) }, + { &ncounts, sizeof (ncounts) } + }; + struct iovec bbbody[8]; + size_t nfilled; + + for (i = 0; i < (sizeof (bbbody) / sizeof (bbbody[0])); i += 2) + { + bbbody[i].iov_len = sizeof (grp->addresses[0]); + bbbody[i + 1].iov_len = sizeof (grp->counts[0]); + } + + /* 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; + writev (fd, bbhead, 2); + for (nfilled = i = 0; i < ncounts; ++i) + { + if (nfilled > (sizeof (bbbody) / sizeof (bbbody[0])) - 2) + { + writev (fd, bbbody, nfilled); + nfilled = 0; + } + + bbbody[nfilled++].iov_base = (char *) &grp->addresses[i]; + bbbody[nfilled++].iov_base = &grp->counts[i]; + } + if (nfilled > 0) + writev (fd, bbbody, nfilled); + } +} + + +static void write_gmon (void) +{ + struct gmon_hdr ghdr __attribute__ ((aligned (__alignof__ (int)))); + int fd = -1; + char *env; + +#ifndef O_NOFOLLOW +# define O_NOFOLLOW 0 +#endif + + env = getenv ("GMON_OUT_PREFIX"); + if (env != NULL +#if 0 + && !__libc_enable_secure +#endif + ) + { + size_t len = strlen (env); + char buf[len + 20]; + sprintf (buf, "%s.%u", env, getpid ()); + fd = open (buf, O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666); + } + + if (fd == -1) + { + fd = open ("gmon.out", O_CREAT|O_TRUNC|O_WRONLY|O_NOFOLLOW, 0666); + if (fd < 0) + { + char buf[300]; + int errnum = errno; + fprintf (stderr, "_mcleanup: gmon.out: %s\n", + strerror_r (errnum, buf, sizeof buf)); + return; + } + } + + /* write gmon.out header: */ + memset (&ghdr, '\0', sizeof (struct gmon_hdr)); + memcpy (&ghdr.cookie[0], GMON_MAGIC, sizeof (ghdr.cookie)); + *(int32_t *) ghdr.version = GMON_VERSION; + write (fd, &ghdr, sizeof (struct gmon_hdr)); + + /* write PC histogram: */ + write_hist (fd); + + /* write call-graph: */ + write_call_graph (fd); + + /* write basic-block execution counts: */ + write_bb_counts (fd); + + close (fd); +} + + +void write_profiling (void) +{ + int save = _gmonparam.state; + _gmonparam.state = GMON_PROF_OFF; + if (save == GMON_PROF_ON) + write_gmon (); + _gmonparam.state = save; +} + + +void _mcleanup (void) +{ + moncontrol (0); + + if (_gmonparam.state != GMON_PROF_ERROR) + write_gmon (); + + /* free the memory. */ + if (_gmonparam.tos != NULL) + free (_gmonparam.tos); +} + +#ifndef SIGPROF + +/* Enable statistical profiling, writing samples of the PC into at most + SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling + is enabled, the system examines the user PC and increments + SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536]. If SCALE is zero, + disable profiling. Returns zero on success, -1 on error. */ + +int profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale) +{ + if (scale == 0) + /* Disable profiling. */ + return 0; + + __set_errno (ENOSYS); + return -1; +} + +#else + +static u_short *samples; +static size_t nsamples; +static size_t pc_offset; +static u_int pc_scale; + +static inline void profil_count (void *pc) +{ + size_t i = (pc - pc_offset - (void *) 0) / 2; + + if (sizeof (unsigned long long int) > sizeof (size_t)) + i = (unsigned long long int) i * pc_scale / 65536; + else + i = i / 65536 * pc_scale + i % 65536 * pc_scale / 65536; + + if (i < nsamples) + ++samples[i]; +} + +/* Get the machine-dependent definition of `profil_counter', the signal + handler for SIGPROF. It calls `profil_count' (above) with the PC of the + interrupted code. */ +#include <bits/profil-counter.h> + +/* Enable statistical profiling, writing samples of the PC into at most + SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling + is enabled, the system examines the user PC and increments + SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536]. If SCALE is zero, + disable profiling. Returns zero on success, -1 on error. */ + +int profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale) +{ + static struct sigaction oact; + static struct itimerval otimer; + struct sigaction act; + struct itimerval timer; + + if (sample_buffer == NULL) + { + /* Disable profiling. */ + if (samples == NULL) + /* Wasn't turned on. */ + return 0; + + if (setitimer (ITIMER_PROF, &otimer, NULL) < 0) + return -1; + samples = NULL; + return sigaction (SIGPROF, &oact, NULL); + } + + if (samples) + { + /* Was already turned on. Restore old timer and signal handler + first. */ + if (setitimer (ITIMER_PROF, &otimer, NULL) < 0 + || sigaction (SIGPROF, &oact, NULL) < 0) + return -1; + } + + samples = sample_buffer; + nsamples = size / sizeof *samples; + pc_offset = offset; + pc_scale = scale; + + act.sa_handler = (__sighandler_t) &profil_counter; + act.sa_flags = SA_RESTART; + __sigfillset (&act.sa_mask); + if (sigaction (SIGPROF, &act, &oact) < 0) + return -1; + + timer.it_value.tv_sec = 0; + timer.it_value.tv_usec = 1; + timer.it_interval = timer.it_value; + return setitimer (ITIMER_PROF, &timer, &otimer); +} + +#endif + + +/* This file provides the machine-dependent definitions of the _MCOUNT_DECL + and MCOUNT macros. */ +#include <bits/machine-gmon.h> +#include <bits/atomicity.h> + +/* + * mcount is called on entry to each function compiled with the profiling + * switch set. _mcount(), which is declared in a machine-dependent way + * with _MCOUNT_DECL, does the actual work and is either inlined into a + * C routine or called by an assembly stub. In any case, this magic is + * taken care of by the MCOUNT definition in <machine/profile.h>. + * + * _mcount updates data structures that represent traversals of the + * program's call graph edges. frompc and selfpc are the return + * address and function address that represents the given call graph edge. + * + * Note: the original BSD code used the same variable (frompcindex) for + * both frompcindex and frompc. Any reasonable, modern compiler will + * perform this optimization. + */ +_MCOUNT_DECL(frompc, selfpc) /* _mcount; may be static, inline, etc */ +{ + register ARCINDEX *frompcindex; + register struct tostruct *top, *prevtop; + register struct gmonparam *p; + register ARCINDEX toindex; + int i; + + p = &_gmonparam; + /* + * check that we are profiling + * and that we aren't recursively invoked. + */ + if (! compare_and_swap (&p->state, GMON_PROF_ON, GMON_PROF_BUSY)) + return; + + /* + * check that frompcindex is a reasonable pc value. + * for example: signal catchers get called from the stack, + * not from text space. too bad. + */ + frompc -= p->lowpc; + if (frompc > p->textsize) + goto done; + + /* The following test used to be + if (p->log_hashfraction >= 0) + But we can simplify this if we assume the profiling data + is always initialized by the functions in gmon.c. But + then it is possible to avoid a runtime check and use the + smae `if' as in gmon.c. So keep these tests in sync. */ + if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) { + /* avoid integer divide if possible: */ + i = frompc >> p->log_hashfraction; + } else { + i = frompc / (p->hashfraction * sizeof(*p->froms)); + } + frompcindex = &p->froms[i]; + toindex = *frompcindex; + if (toindex == 0) { + /* + * first time traversing this arc + */ + toindex = ++p->tos[0].link; + if (toindex >= p->tolimit) + /* halt further profiling */ + goto overflow; + + *frompcindex = toindex; + top = &p->tos[toindex]; + top->selfpc = selfpc; + top->count = 1; + top->link = 0; + goto done; + } + top = &p->tos[toindex]; + if (top->selfpc == selfpc) { + /* + * arc at front of chain; usual case. + */ + top->count++; + goto done; + } + /* + * have to go looking down chain for it. + * top points to what we are looking at, + * prevtop points to previous top. + * we know it is not at the head of the chain. + */ + for (; /* goto done */; ) { + if (top->link == 0) { + /* + * top is end of the chain and none of the chain + * had top->selfpc == selfpc. + * so we allocate a new tostruct + * and link it to the head of the chain. + */ + toindex = ++p->tos[0].link; + if (toindex >= p->tolimit) + goto overflow; + + top = &p->tos[toindex]; + top->selfpc = selfpc; + top->count = 1; + top->link = *frompcindex; + *frompcindex = toindex; + goto done; + } + /* + * otherwise, check the next arc on the chain. + */ + prevtop = top; + top = &p->tos[top->link]; + if (top->selfpc == selfpc) { + /* + * there it is. + * increment its count + * move it to the head of the chain. + */ + top->count++; + toindex = prevtop->link; + prevtop->link = top->link; + top->link = *frompcindex; + *frompcindex = toindex; + goto done; + } + + } +done: + p->state = GMON_PROF_ON; + return; +overflow: + p->state = GMON_PROF_ERROR; + return; +} + +/* + * Actual definition of mcount function. Defined in <machine/profile.h>, + * which is included by <sys/gmon.h>. + */ +MCOUNT + +#endif + diff --git a/libc/sysdeps/linux/common/initfini.c b/libc/sysdeps/linux/common/initfini.c index 64fdf6eb4..ba4d68fc9 100644 --- a/libc/sysdeps/linux/common/initfini.c +++ b/libc/sysdeps/linux/common/initfini.c @@ -38,7 +38,6 @@ #include <features.h> -#undef GMON_SUPPORT /* We use embedded asm for .section unconditionally, as this makes it easier to insert the necessary directives into crtn.S. */ @@ -87,6 +86,7 @@ dummy (void (*foo) (void)) asm ("\n/*@_init_PROLOG_BEGINS*/"); #ifdef GMON_SUPPORT +asm ("\n/*@_init_GMON_STUFF_BEGINS*/"); static void call_gmon_start(void) { @@ -96,6 +96,7 @@ call_gmon_start(void) if (gmon_start) gmon_start (); } +asm ("\n/*@_init_GMON_STUFF_PAUSES*/"); #endif SECTION (".init") @@ -106,6 +107,7 @@ extern void _init (void); void _init (void) { #ifdef GMON_SUPPORT +asm ("\n/*@_init_GMON_STUFF_UNPAUSES*/"); /* We cannot use the normal constructor mechanism in gcrt1.o because it appears before crtbegin.o in the link, so the header elt of .ctors would come after the elt for __gmon_start__. One approach is for @@ -113,6 +115,7 @@ void _init (void) module which has a constructor; but then user code's constructors would come first, and not be profiled. */ call_gmon_start (); +asm ("\n/*@_init_GMON_STUFF_ENDS*/"); #else asm ("\n/*@_init_PROLOG_PAUSES*/"); { |