mcount.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1983, 1992, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by the University of
   16  *      California, Berkeley and its contributors.
   17  * 4. Neither the name of the University nor the names of its contributors
   18  *    may be used to endorse or promote products derived from this software
   19  *    without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31  * SUCH DAMAGE.
   32  *
   33  * $FreeBSD$
   34  */
   35 
   36 #include <sys/param.h>
   37 #include <sys/gmon.h>
   38 #ifdef _KERNEL
   39 #ifndef GUPROF
   40 #include <sys/systm.h>
   41 #endif
   42 #include <vm/vm.h>
   43 #include <vm/vm_param.h>
   44 #include <vm/pmap.h>
   45 void    bintr __P((void));
   46 void    btrap __P((void));
   47 void    eintr __P((void));
   48 void    user __P((void));
   49 #endif
   50 
   51 /*
   52  * mcount is called on entry to each function compiled with the profiling
   53  * switch set.  _mcount(), which is declared in a machine-dependent way
   54  * with _MCOUNT_DECL, does the actual work and is either inlined into a
   55  * C routine or called by an assembly stub.  In any case, this magic is
   56  * taken care of by the MCOUNT definition in <machine/profile.h>.
   57  *
   58  * _mcount updates data structures that represent traversals of the
   59  * program's call graph edges.  frompc and selfpc are the return
   60  * address and function address that represents the given call graph edge.
   61  *
   62  * Note: the original BSD code used the same variable (frompcindex) for
   63  * both frompcindex and frompc.  Any reasonable, modern compiler will
   64  * perform this optimization.
   65  */
   66 _MCOUNT_DECL(frompc, selfpc)    /* _mcount; may be static, inline, etc */
   67         register uintfptr_t frompc, selfpc;
   68 {
   69 #ifdef GUPROF
   70         int delta;
   71 #endif
   72         register fptrdiff_t frompci;
   73         register u_short *frompcindex;
   74         register struct tostruct *top, *prevtop;
   75         register struct gmonparam *p;
   76         register long toindex;
   77 #ifdef _KERNEL
   78         MCOUNT_DECL(s)
   79 #endif
   80 
   81         p = &_gmonparam;
   82 #ifndef GUPROF                  /* XXX */
   83         /*
   84          * check that we are profiling
   85          * and that we aren't recursively invoked.
   86          */
   87         if (p->state != GMON_PROF_ON)
   88                 return;
   89 #endif
   90 #ifdef _KERNEL
   91         MCOUNT_ENTER(s);
   92 #else
   93         p->state = GMON_PROF_BUSY;
   94 #endif
   95         frompci = frompc - p->lowpc;
   96 
   97 #ifdef _KERNEL
   98         /*
   99          * When we are called from an exception handler, frompci may be
  100          * for a user address.  Convert such frompci's to the index of
  101          * user() to merge all user counts.
  102          */
  103         if (frompci >= p->textsize) {
  104                 if (frompci + p->lowpc
  105                     >= (uintfptr_t)(VM_MAXUSER_ADDRESS + UPAGES * PAGE_SIZE))
  106                         goto done;
  107                 frompci = (uintfptr_t)user - p->lowpc;
  108                 if (frompci >= p->textsize)
  109                     goto done;
  110         }
  111 #endif
  112 
  113 #ifdef GUPROF
  114         if (p->state == GMON_PROF_HIRES) {
  115                 /*
  116                  * Count the time since cputime() was previously called
  117                  * against `frompc'.  Compensate for overheads.
  118                  *
  119                  * cputime() sets its prev_count variable to the count when
  120                  * it is called.  This in effect starts a counter for
  121                  * the next period of execution (normally from now until 
  122                  * the next call to mcount() or mexitcount()).  We set
  123                  * cputime_bias to compensate for our own overhead.
  124                  *
  125                  * We use the usual sampling counters since they can be
  126                  * located efficiently.  4-byte counters are usually
  127                  * necessary.  gprof will add up the scattered counts
  128                  * just like it does for statistical profiling.  All
  129                  * counts are signed so that underflow in the subtractions
  130                  * doesn't matter much (negative counts are normally
  131                  * compensated for by larger counts elsewhere).  Underflow
  132                  * shouldn't occur, but may be caused by slightly wrong
  133                  * calibrations or from not clearing cputime_bias.
  134                  */
  135                 delta = cputime() - cputime_bias - p->mcount_pre_overhead;
  136                 cputime_bias = p->mcount_post_overhead;
  137                 KCOUNT(p, frompci) += delta;
  138                 *p->cputime_count += p->cputime_overhead;
  139                 *p->mcount_count += p->mcount_overhead;
  140         }
  141 #endif /* GUPROF */
  142 
  143 #ifdef _KERNEL
  144         /*
  145          * When we are called from an exception handler, frompc is faked
  146          * to be for where the exception occurred.  We've just solidified
  147          * the count for there.  Now convert frompci to the index of btrap()
  148          * for trap handlers and bintr() for interrupt handlers to make
  149          * exceptions appear in the call graph as calls from btrap() and
  150          * bintr() instead of calls from all over.
  151          */
  152         if ((uintfptr_t)selfpc >= (uintfptr_t)btrap
  153             && (uintfptr_t)selfpc < (uintfptr_t)eintr) {
  154                 if ((uintfptr_t)selfpc >= (uintfptr_t)bintr)
  155                         frompci = (uintfptr_t)bintr - p->lowpc;
  156                 else
  157                         frompci = (uintfptr_t)btrap - p->lowpc;
  158         }
  159 #endif
  160 
  161         /*
  162          * check that frompc is a reasonable pc value.
  163          * for example: signal catchers get called from the stack,
  164          *              not from text space.  too bad.
  165          */
  166         if (frompci >= p->textsize)
  167                 goto done;
  168 
  169         frompcindex = &p->froms[frompci / (p->hashfraction * sizeof(*p->froms))];
  170         toindex = *frompcindex;
  171         if (toindex == 0) {
  172                 /*
  173                  *      first time traversing this arc
  174                  */
  175                 toindex = ++p->tos[0].link;
  176                 if (toindex >= p->tolimit)
  177                         /* halt further profiling */
  178                         goto overflow;
  179 
  180                 *frompcindex = toindex;
  181                 top = &p->tos[toindex];
  182                 top->selfpc = selfpc;
  183                 top->count = 1;
  184                 top->link = 0;
  185                 goto done;
  186         }
  187         top = &p->tos[toindex];
  188         if (top->selfpc == selfpc) {
  189                 /*
  190                  * arc at front of chain; usual case.
  191                  */
  192                 top->count++;
  193                 goto done;
  194         }
  195         /*
  196          * have to go looking down chain for it.
  197          * top points to what we are looking at,
  198          * prevtop points to previous top.
  199          * we know it is not at the head of the chain.
  200          */
  201         for (; /* goto done */; ) {
  202                 if (top->link == 0) {
  203                         /*
  204                          * top is end of the chain and none of the chain
  205                          * had top->selfpc == selfpc.
  206                          * so we allocate a new tostruct
  207                          * and link it to the head of the chain.
  208                          */
  209                         toindex = ++p->tos[0].link;
  210                         if (toindex >= p->tolimit)
  211                                 goto overflow;
  212 
  213                         top = &p->tos[toindex];
  214                         top->selfpc = selfpc;
  215                         top->count = 1;
  216                         top->link = *frompcindex;
  217                         *frompcindex = toindex;
  218                         goto done;
  219                 }
  220                 /*
  221                  * otherwise, check the next arc on the chain.
  222                  */
  223                 prevtop = top;
  224                 top = &p->tos[top->link];
  225                 if (top->selfpc == selfpc) {
  226                         /*
  227                          * there it is.
  228                          * increment its count
  229                          * move it to the head of the chain.
  230                          */
  231                         top->count++;
  232                         toindex = prevtop->link;
  233                         prevtop->link = top->link;
  234                         top->link = *frompcindex;
  235                         *frompcindex = toindex;
  236                         goto done;
  237                 }
  238 
  239         }
  240 done:
  241 #ifdef _KERNEL
  242         MCOUNT_EXIT(s);
  243 #else
  244         p->state = GMON_PROF_ON;
  245 #endif
  246         return;
  247 overflow:
  248         p->state = GMON_PROF_ERROR;
  249 #ifdef _KERNEL
  250         MCOUNT_EXIT(s);
  251 #endif
  252         return;
  253 }
  254 
  255 /*
  256  * Actual definition of mcount function.  Defined in <machine/profile.h>,
  257  * which is included by <sys/gmon.h>.
  258  */
  259 MCOUNT
  260 
  261 #ifdef GUPROF
  262 void
  263 mexitcount(selfpc)
  264         uintfptr_t selfpc;
  265 {
  266         struct gmonparam *p;
  267         uintfptr_t selfpcdiff;
  268 
  269         p = &_gmonparam;
  270         selfpcdiff = selfpc - (uintfptr_t)p->lowpc;
  271         if (selfpcdiff < p->textsize) {
  272                 int delta;
  273 
  274                 /*
  275                  * Count the time since cputime() was previously called
  276                  * against `selfpc'.  Compensate for overheads.
  277                  */
  278                 delta = cputime() - cputime_bias - p->mexitcount_pre_overhead;
  279                 cputime_bias = p->mexitcount_post_overhead;
  280                 KCOUNT(p, selfpcdiff) += delta;
  281                 *p->cputime_count += p->cputime_overhead;
  282                 *p->mexitcount_count += p->mexitcount_overhead;
  283         }
  284 }
  285 
  286 void
  287 empty_loop()
  288 {
  289         int i;
  290 
  291         for (i = 0; i < CALIB_SCALE; i++)
  292                 ;
  293 }
  294 
  295 void
  296 nullfunc()
  297 {
  298 }
  299 
  300 void
  301 nullfunc_loop()
  302 {
  303         int i;
  304 
  305         for (i = 0; i < CALIB_SCALE; i++)
  306                 nullfunc();
  307 }
  308 #endif /* GUPROF */
Cache object: 47cd1fb233b1adf37a0e3032a64da677
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/libkern/mcount.c

FreeBSD/Linux Kernel Cross Reference
sys/libkern/mcount.c
