gcc/config/i386/gmon-sol2.c

   1 /*-
   2  * Copyright (c) 1991 The Regents of the University of California.
   3  * 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. [rescinded 22 July 1999]
  14  * 4. Neither the name of the University nor the names of its contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 /*
  32  * This is a modified gmon.c by J.W.Hawtin <oolon@ankh.org>,
  33  * 14/8/96 based on the original gmon.c in GCC and the hacked version
  34  * solaris 2 sparc version (config/sparc/gmon-sol.c) by Mark Eichin. To do
  35  * process profiling on solaris 2.X X86
  36  *
  37  * It must be used in conjunction with sol2-gc1.asm, which is used to start
  38  * and stop process monitoring.
  39  *
  40  * Differences.
  41  *
  42  * On Solaris 2 _mcount is called by library functions not mcount, so support
  43  * has been added for both.
  44  *
  45  * Also the prototype for profil() is different
  46  *
  47  * Solaris 2 does not seem to have char *minbrk whcih allows the setting of
  48  * the minimum SBRK region so this code has been removed and lets pray malloc
  49  * does not mess it up.
  50  *
  51  * Notes
  52  *
  53  * This code could easily be integrated with the original gmon.c and perhaps
  54  * should be.
  55  */
  56 #include "tconfig.h"
  57 #include "tsystem.h"
  58 #include <fcntl.h> /* for creat() */
  59
  60 #ifdef DEBUG
  61 #include <stdio.h>
  62 #endif
  63
  64 static void moncontrol (int);
  65 extern void monstartup (char *, char *);
  66 extern void _mcleanup (void);
  67 extern void internal_mcount (
  68 #ifdef __x86_64__
  69                              char *, unsigned short *
  70 #else
  71                              void
  72 #endif
  73                              );
  74
  75
  76 struct phdr {
  77                 char    *lpc;
  78                 char    *hpc;
  79                 int     ncnt;
  80 };
  81
  82
  83 #define HISTFRACTION 2
  84 #define HISTCOUNTER unsigned short
  85 #define HASHFRACTION 1
  86 #define ARCDENSITY 2
  87 #define MINARCS 50
  88 #define BASEADDRESS 0x8000000 /* On Solaris 2 X86 all executables start here
  89                                  and not at 0 */
  90
  91 struct tostruct {
  92   char *selfpc;
  93   long count;
  94   unsigned short link;
  95 };
  96
  97 struct rawarc {
  98     unsigned long       raw_frompc;
  99     unsigned long       raw_selfpc;
 100     long                raw_count;
 101 };
 102 #define ROUNDDOWN(x,y)  (((x)/(y))*(y))
 103 #define ROUNDUP(x,y)    ((((x)+(y)-1)/(y))*(y))
 104
 105 /* char *minbrk; */
 106
 107 typedef __SIZE_TYPE__ size_t;
 108 typedef __PTRDIFF_TYPE__ intptr_t;
 109
 110     /*
 111      *  froms is actually a bunch of unsigned shorts indexing tos
 112      */
 113 static int              profiling = 3;
 114 static unsigned short   *froms;
 115 static struct tostruct  *tos = 0;
 116 static long             tolimit = 0;
 117 static char             *s_lowpc = 0;
 118 static char             *s_highpc = 0;
 119 static size_t           s_textsize = 0;
 120
 121 static int      ssiz;
 122 static char     *sbuf;
 123 static int      s_scale;
 124     /* see profil(2) where this is describe (incorrectly) */
 125 #define         SCALE_1_TO_1    0x10000L
 126
 127 #define MSG "No space for profiling buffer(s)\n"
 128
 129 extern int errno;
 130
 131 extern void *sbrk (intptr_t);
 132
 133 void
 134 monstartup(char *lowpc, char *highpc)
 135 {
 136     size_t              monsize;
 137     char                *buffer;
 138     register size_t     o;
 139
 140         /*
 141          *      round lowpc and highpc to multiples of the density we're using
 142          *      so the rest of the scaling (here and in gprof) stays in ints.
 143          */
 144     lowpc = (char *)
 145             ROUNDDOWN((size_t)lowpc, HISTFRACTION*sizeof(HISTCOUNTER));
 146     s_lowpc = lowpc;
 147     highpc = (char *)
 148             ROUNDUP((size_t)highpc, HISTFRACTION*sizeof(HISTCOUNTER));
 149     s_highpc = highpc;
 150     s_textsize = highpc - lowpc;
 151     monsize = (s_textsize / HISTFRACTION) + sizeof(struct phdr);
 152     buffer = (char *) sbrk( monsize );
 153     if ( buffer == (char *) -1 ) {
 154         write( 2 , MSG , sizeof(MSG) );
 155         return;
 156     }
 157     froms = (unsigned short *) sbrk( s_textsize / HASHFRACTION );
 158     if ( froms == (unsigned short *) -1 ) {
 159         write( 2 , MSG , sizeof(MSG) );
 160         froms = 0;
 161         return;
 162     }
 163     tolimit = s_textsize * ARCDENSITY / 100;
 164     if ( tolimit < MINARCS ) {
 165         tolimit = MINARCS;
 166     } else if ( tolimit > 65534 ) {
 167         tolimit = 65534;
 168     }
 169     tos = (struct tostruct *) sbrk( tolimit * sizeof( struct tostruct ) );
 170     if ( tos == (struct tostruct *) -1 ) {
 171         write( 2 , MSG , sizeof(MSG) );
 172         froms = 0;
 173         tos = 0;
 174         return;
 175     }
 176 /*    minbrk = (char *) sbrk(0);*/
 177     tos[0].link = 0;
 178     sbuf = buffer;
 179     ssiz = monsize;
 180     ( (struct phdr *) buffer ) -> lpc = lowpc;
 181     ( (struct phdr *) buffer ) -> hpc = highpc;
 182     ( (struct phdr *) buffer ) -> ncnt = ssiz;
 183     monsize -= sizeof(struct phdr);
 184     if ( monsize <= 0 )
 185         return;
 186     o = highpc - lowpc;
 187     if( monsize < o )
 188 #ifndef hp300
 189         s_scale = ( (float) monsize / o ) * SCALE_1_TO_1;
 190 #else /* avoid floating point */
 191     {
 192         int quot = o / monsize;
 193
 194         if (quot >= 0x10000)
 195                 s_scale = 1;
 196         else if (quot >= 0x100)
 197                 s_scale = 0x10000 / quot;
 198         else if (o >= 0x800000)
 199                 s_scale = 0x1000000 / (o / (monsize >> 8));
 200         else
 201                 s_scale = 0x1000000 / ((o << 8) / monsize);
 202     }
 203 #endif
 204     else
 205         s_scale = SCALE_1_TO_1;
 206     moncontrol(1);
 207 }
 208
 209 void
 210 _mcleanup (void)
 211 {
 212     int                 fd;
 213     int                 fromindex;
 214     int                 endfrom;
 215     char                *frompc;
 216     int                 toindex;
 217     struct rawarc       rawarc;
 218
 219     moncontrol(0);
 220     fd = creat( "gmon.out" , 0666 );
 221     if ( fd < 0 ) {
 222         perror( "mcount: gmon.out" );
 223         return;
 224     }
 225 #   ifdef DEBUG
 226         fprintf( stderr , "[mcleanup] sbuf 0x%x ssiz %d\n" , sbuf , ssiz );
 227 #   endif /* DEBUG */
 228
 229     write( fd , sbuf , ssiz );
 230     endfrom = s_textsize / (HASHFRACTION * sizeof(*froms));
 231     for ( fromindex = 0 ; fromindex < endfrom ; fromindex++ ) {
 232         if ( froms[fromindex] == 0 ) {
 233             continue;
 234         }
 235         frompc = s_lowpc + (fromindex * HASHFRACTION * sizeof(*froms));
 236         for (toindex=froms[fromindex]; toindex!=0; toindex=tos[toindex].link) {
 237 #           ifdef DEBUG
 238                 fprintf( stderr ,
 239                         "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
 240                         frompc , tos[toindex].selfpc , tos[toindex].count );
 241 #           endif /* DEBUG */
 242             rawarc.raw_frompc = (unsigned long) frompc;
 243             rawarc.raw_selfpc = (unsigned long) tos[toindex].selfpc;
 244             rawarc.raw_count = tos[toindex].count;
 245             write( fd , &rawarc , sizeof rawarc );
 246         }
 247     }
 248     close( fd );
 249 }
 250
 251 #ifdef __x86_64__
 252 /* See GLIBC for additional information about this technique.  */
 253 asm(".globl _mcount\n"
 254     "\t.type\t_mcount, @function\n"
 255     "_mcount:\n"
 256     /* The compiler calls _mcount after the prologue, and does not
 257        save any of the registers.  Therefore we must preserve all
 258        seven registers which may contain function arguments.  */
 259     "\tsubq\t$0x38,%rsp\n"
 260     "\tmovq\t%rax,(%rsp)\n"
 261     "\tmovq\t%rcx,0x08(%rsp)\n"
 262     "\tmovq\t%rdx,0x10(%rsp)\n"
 263     "\tmovq\t%rsi,0x18(%rsp)\n"
 264     "\tmovq\t%rdi,0x20(%rsp)\n"
 265     "\tmovq\t%r8,0x28(%rsp)\n"
 266     "\tmovq\t%r9,0x30(%rsp)\n"
 267     /* Get SELFPC (pushed by the call to this function) and
 268        FROMPCINDEX (via the frame pointer.  */
 269     "\tmovq\t0x38(%rsp),%rdi\n"
 270     "\tmovq\t0x8(%rbp),%rsi\n"
 271     "\tcallq\tinternal_mcount\n"
 272     /* Restore the saved registers.  */
 273     "\tmovq\t0x30(%rsp),%r9\n"
 274     "\tmovq\t0x28(%rsp),%r8\n"
 275     "\tmovq\t0x20(%rsp),%rdi\n"
 276     "\tmovq\t0x18(%rsp),%rsi\n"
 277     "\tmovq\t0x10(%rsp),%rdx\n"
 278     "\tmovq\t0x08(%rsp),%rdx\n"
 279     "\tmovq\t(%rsp),%rax\n"
 280     "\taddq\t$0x38,%rsp\n"
 281     "\tretq\n"
 282     );
 283 #else
 284 /* Solaris 2 libraries use _mcount.  */
 285 asm(".globl _mcount; _mcount: jmp internal_mcount");
 286 /* This is for compatibility with old versions of gcc which used mcount.  */
 287 asm(".globl mcount; mcount: jmp internal_mcount");
 288 #endif
 289
 290 void
 291 internal_mcount (
 292 #ifdef __x86_64__
 293                  char *selfpc,
 294                  unsigned short *frompcindex
 295 #else
 296                  void
 297 #endif
 298                  )
 299 {
 300 #ifndef __x86_64__
 301         register char                   *selfpc;
 302         register unsigned short         *frompcindex;
 303 #endif
 304         register struct tostruct        *top;
 305         register struct tostruct        *prevtop;
 306         register long                   toindex;
 307         static char already_setup;
 308
 309 #ifndef __x86_64__
 310         /*
 311          *      find the return address for mcount,
 312          *      and the return address for mcount's caller.
 313          */
 314
 315         /* selfpc = pc pushed by mcount call.
 316            This identifies the function that was just entered.  */
 317         selfpc = (void *) __builtin_return_address (0);
 318         /* frompcindex = pc in preceding frame.
 319            This identifies the caller of the function just entered.  */
 320         frompcindex = (void *) __builtin_return_address (1);
 321 #endif
 322
 323         if(!already_setup) {
 324           extern char etext[];
 325           already_setup = 1;
 326 #ifdef __x86_64__
 327           monstartup(0, etext);
 328 #else
 329           monstartup((char*)0x08040000, etext);
 330 #endif
 331 #ifdef USE_ONEXIT
 332           on_exit(_mcleanup, 0);
 333 #else
 334           atexit(_mcleanup);
 335 #endif
 336         }
 337         /*
 338          *      check that we are profiling
 339          *      and that we aren't recursively invoked.
 340          */
 341         if (profiling) {
 342                 goto out;
 343         }
 344         profiling++;
 345         /*
 346          *      check that frompcindex is a reasonable pc value.
 347          *      for example:    signal catchers get called from the stack,
 348          *                      not from text space.  too bad.
 349          */
 350         frompcindex = (unsigned short *)((long)frompcindex - (long)s_lowpc);
 351         if ((unsigned long)frompcindex > s_textsize) {
 352                 goto done;
 353         }
 354         frompcindex =
 355             &froms[((long)frompcindex) / (HASHFRACTION * sizeof(*froms))];
 356         toindex = *frompcindex;
 357         if (toindex == 0) {
 358                 /*
 359                  *      first time traversing this arc
 360                  */
 361                 toindex = ++tos[0].link;
 362                 if (toindex >= tolimit) {
 363                         goto overflow;
 364                 }
 365                 *frompcindex = toindex;
 366                 top = &tos[toindex];
 367                 top->selfpc = selfpc;
 368                 top->count = 1;
 369                 top->link = 0;
 370                 goto done;
 371         }
 372         top = &tos[toindex];
 373         if (top->selfpc == selfpc) {
 374                 /*
 375                  *      arc at front of chain; usual case.
 376                  */
 377                 top->count++;
 378                 goto done;
 379         }
 380         /*
 381          *      have to go looking down chain for it.
 382          *      top points to what we are looking at,
 383          *      prevtop points to previous top.
 384          *      we know it is not at the head of the chain.
 385          */
 386         for (; /* goto done */; ) {
 387                 if (top->link == 0) {
 388                         /*
 389                          *      top is end of the chain and none of the chain
 390                          *      had top->selfpc == selfpc.
 391                          *      so we allocate a new tostruct
 392                          *      and link it to the head of the chain.
 393                          */
 394                         toindex = ++tos[0].link;
 395                         if (toindex >= tolimit) {
 396                                 goto overflow;
 397                         }
 398                         top = &tos[toindex];
 399                         top->selfpc = selfpc;
 400                         top->count = 1;
 401                         top->link = *frompcindex;
 402                         *frompcindex = toindex;
 403                         goto done;
 404                 }
 405                 /*
 406                  *      otherwise, check the next arc on the chain.
 407                  */
 408                 prevtop = top;
 409                 top = &tos[top->link];
 410                 if (top->selfpc == selfpc) {
 411                         /*
 412                          *      there it is.
 413                          *      increment its count
 414                          *      move it to the head of the chain.
 415                          */
 416                         top->count++;
 417                         toindex = prevtop->link;
 418                         prevtop->link = top->link;
 419                         top->link = *frompcindex;
 420                         *frompcindex = toindex;
 421                         goto done;
 422                 }
 423
 424         }
 425 done:
 426         profiling--;
 427         /* and fall through */
 428 out:
 429         return;         /* normal return restores saved registers */
 430
 431 overflow:
 432         profiling++; /* halt further profiling */
 433 #   define      TOLIMIT "mcount: tos overflow\n"
 434         write(2, TOLIMIT, sizeof(TOLIMIT));
 435         goto out;
 436 }
 437
 438 /*
 439  * Control profiling
 440  *      profiling is what mcount checks to see if
 441  *      all the data structures are ready.
 442  */
 443 static void
 444 moncontrol(int mode)
 445 {
 446     if (mode)
 447     {
 448       /* start */
 449       profil((unsigned short *)(sbuf + sizeof(struct phdr)),
 450              ssiz - sizeof(struct phdr),
 451              (size_t)s_lowpc, s_scale);
 452
 453       profiling = 0;
 454     } else {
 455       /* stop */
 456       profil((unsigned short *)0, 0, 0, 0);
 457       profiling = 3;
 458     }
 459 }