common/lib/libc/gmon/mcount.c

   1 /*      $NetBSD: mcount.c,v 1.8 2009/01/05 18:06:57 pooka Exp $ */
   2
   3 /*
   4  * Copyright (c) 2003, 2004 Wasabi Systems, Inc.
   5  * All rights reserved.
   6  *
   7  * Written by Nathan J. Williams for Wasabi Systems, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed for the NetBSD Project by
  20  *      Wasabi Systems, Inc.
  21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  22  *    or promote products derived from this software without specific prior
  23  *    written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 /*-
  39  * Copyright (c) 1983, 1992, 1993
  40  *      The Regents of the University of California.  All rights reserved.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  */
  66
  67 /* If building a standalone libkern, don't include mcount. */
  68 #if (!defined(_KERNEL) || defined(GPROF)) && !defined(_STANDALONE)
  69
  70 #ifdef _KERNEL_OPT
  71 #include "opt_multiprocessor.h"
  72 #endif
  73
  74 #include <sys/cdefs.h>
  75 #if !defined(lint) && !defined(_KERNEL) && defined(LIBC_SCCS)
  76 #if 0
  77 static char sccsid[] = "@(#)mcount.c    8.1 (Berkeley) 6/4/93";
  78 #else
  79 __RCSID("$NetBSD: mcount.c,v 1.8 2009/01/05 18:06:57 pooka Exp $");
  80 #endif
  81 #endif
  82
  83 #include <sys/param.h>
  84 #include <sys/gmon.h>
  85
  86 #ifndef _KERNEL
  87 #include "reentrant.h"
  88 #endif
  89
  90 #ifdef _REENTRANT
  91 extern thread_key_t _gmonkey;
  92 extern struct gmonparam _gmondummy;
  93 struct gmonparam *_m_gmon_alloc(void);
  94 #endif
  95
  96 _MCOUNT_DECL __P((u_long, u_long))
  97 #ifdef _KERNEL
  98     __attribute__((__no_instrument_function__))
  99 #endif
 100     __used;
 101
 102 /* XXX: make these interfaces */
 103 #ifdef _RUMPKERNEL
 104 #undef MCOUNT_ENTER
 105 #define MCOUNT_ENTER
 106 #undef MCOUNT_EXIT
 107 #define MCOUNT_EXIT
 108 #undef MCOUNT
 109 #define MCOUNT
 110 #endif
 111
 112 /*
 113  * mcount is called on entry to each function compiled with the profiling
 114  * switch set.  _mcount(), which is declared in a machine-dependent way
 115  * with _MCOUNT_DECL, does the actual work and is either inlined into a
 116  * C routine or called by an assembly stub.  In any case, this magic is
 117  * taken care of by the MCOUNT definition in <machine/profile.h>.
 118  *
 119  * _mcount updates data structures that represent traversals of the
 120  * program's call graph edges.  frompc and selfpc are the return
 121  * address and function address that represents the given call graph edge.
 122  *
 123  * Note: the original BSD code used the same variable (frompcindex) for
 124  * both frompcindex and frompc.  Any reasonable, modern compiler will
 125  * perform this optimization.
 126  */
 127 _MCOUNT_DECL(frompc, selfpc)    /* _mcount; may be static, inline, etc */
 128         u_long frompc, selfpc;
 129 {
 130         u_short *frompcindex;
 131         struct tostruct *top, *prevtop;
 132         struct gmonparam *p;
 133         long toindex;
 134 #if defined(_KERNEL) && !defined(_RUMPKERNEL)
 135         int s;
 136 #endif
 137
 138 #if defined(_REENTRANT) && !defined(_KERNEL)
 139         if (__isthreaded) {
 140                 p = thr_getspecific(_gmonkey);
 141                 if (p == NULL) {
 142                         /* Prevent recursive calls while allocating */
 143                         thr_setspecific(_gmonkey, &_gmondummy);
 144                         p = _m_gmon_alloc();
 145                 }
 146         } else
 147 #endif
 148                 p = &_gmonparam;
 149         /*
 150          * check that we are profiling
 151          * and that we aren't recursively invoked.
 152          */
 153         if (p->state != GMON_PROF_ON)
 154                 return;
 155 #ifdef _KERNEL
 156         MCOUNT_ENTER;
 157 #endif
 158         p->state = GMON_PROF_BUSY;
 159         /*
 160          * check that frompcindex is a reasonable pc value.
 161          * for example: signal catchers get called from the stack,
 162          *              not from text space.  too bad.
 163          */
 164         frompc -= p->lowpc;
 165         if (frompc > p->textsize)
 166                 goto done;
 167
 168 #if (HASHFRACTION & (HASHFRACTION - 1)) == 0
 169         if (p->hashfraction == HASHFRACTION)
 170                 frompcindex =
 171                     &p->froms[
 172                     (size_t)(frompc / (HASHFRACTION * sizeof(*p->froms)))];
 173         else
 174 #endif
 175                 frompcindex =
 176                     &p->froms[
 177                     (size_t)(frompc / (p->hashfraction * sizeof(*p->froms)))];
 178         toindex = *frompcindex;
 179         if (toindex == 0) {
 180                 /*
 181                  *      first time traversing this arc
 182                  */
 183                 toindex = ++p->tos[0].link;
 184                 if (toindex >= p->tolimit)
 185                         /* halt further profiling */
 186                         goto overflow;
 187
 188                 *frompcindex = (u_short)toindex;
 189                 top = &p->tos[(size_t)toindex];
 190                 top->selfpc = selfpc;
 191                 top->count = 1;
 192                 top->link = 0;
 193                 goto done;
 194         }
 195         top = &p->tos[(size_t)toindex];
 196         if (top->selfpc == selfpc) {
 197                 /*
 198                  * arc at front of chain; usual case.
 199                  */
 200                 top->count++;
 201                 goto done;
 202         }
 203         /*
 204          * have to go looking down chain for it.
 205          * top points to what we are looking at,
 206          * prevtop points to previous top.
 207          * we know it is not at the head of the chain.
 208          */
 209         for (; /* goto done */; ) {
 210                 if (top->link == 0) {
 211                         /*
 212                          * top is end of the chain and none of the chain
 213                          * had top->selfpc == selfpc.
 214                          * so we allocate a new tostruct
 215                          * and link it to the head of the chain.
 216                          */
 217                         toindex = ++p->tos[0].link;
 218                         if (toindex >= p->tolimit)
 219                                 goto overflow;
 220
 221                         top = &p->tos[(size_t)toindex];
 222                         top->selfpc = selfpc;
 223                         top->count = 1;
 224                         top->link = *frompcindex;
 225                         *frompcindex = (u_short)toindex;
 226                         goto done;
 227                 }
 228                 /*
 229                  * otherwise, check the next arc on the chain.
 230                  */
 231                 prevtop = top;
 232                 top = &p->tos[top->link];
 233                 if (top->selfpc == selfpc) {
 234                         /*
 235                          * there it is.
 236                          * increment its count
 237                          * move it to the head of the chain.
 238                          */
 239                         top->count++;
 240                         toindex = prevtop->link;
 241                         prevtop->link = top->link;
 242                         top->link = *frompcindex;
 243                         *frompcindex = (u_short)toindex;
 244                         goto done;
 245                 }
 246
 247         }
 248 done:
 249         p->state = GMON_PROF_ON;
 250 #ifdef _KERNEL
 251         MCOUNT_EXIT;
 252 #endif
 253         return;
 254 overflow:
 255         p->state = GMON_PROF_ERROR;
 256 #ifdef _KERNEL
 257         MCOUNT_EXIT;
 258 #endif
 259         return;
 260 }
 261
 262 #ifdef MCOUNT
 263 /*
 264  * Actual definition of mcount function.  Defined in <machine/profile.h>,
 265  * which is included by <sys/gmon.h>.
 266  */
 267 MCOUNT
 268 #endif
 269
 270 #endif /* (!_KERNEL || GPROF) && !_STANDALONE */