usr.bin/gprof/vax.c

   1 /*
   2  * Copyright (c) 1983, 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  * @(#)vax.c    8.1 (Berkeley) 6/6/93
  34  */
  35
  36 #include        "gprof.h"
  37
  38     /*
  39      *  a namelist entry to be the child of indirect calls
  40      */
  41 nltype  indirectchild = {
  42         "(*)" ,                         /* the name */
  43         (unsigned long) 0 ,             /* the pc entry point */
  44         (unsigned long) 0 ,             /* entry point aligned to histogram */
  45         (double) 0.0 ,                  /* ticks in this routine */
  46         (double) 0.0 ,                  /* cumulative ticks in children */
  47         (long) 0 ,                      /* how many times called */
  48         (long) 0 ,                      /* how many calls to self */
  49         (double) 1.0 ,                  /* propagation fraction */
  50         (double) 0.0 ,                  /* self propagation time */
  51         (double) 0.0 ,                  /* child propagation time */
  52         (bool) 0 ,                      /* print flag */
  53         (int) 0 ,                       /* index in the graph list */
  54         (int) 0 ,                       /* graph call chain top-sort order */
  55         (int) 0 ,                       /* internal number of cycle on */
  56         (struct nl *) &indirectchild ,  /* pointer to head of cycle */
  57         (struct nl *) 0 ,               /* pointer to next member of cycle */
  58         (arctype *) 0 ,                 /* list of caller arcs */
  59         (arctype *) 0                   /* list of callee arcs */
  60     };
  61
  62 operandenum
  63 operandmode( modep )
  64     struct modebyte     *modep;
  65 {
  66     long        usesreg = modep -> regfield;
  67
  68     switch ( modep -> modefield ) {
  69         case 0:
  70         case 1:
  71         case 2:
  72         case 3:
  73             return literal;
  74         case 4:
  75             return indexed;
  76         case 5:
  77             return reg;
  78         case 6:
  79             return regdef;
  80         case 7:
  81             return autodec;
  82         case 8:
  83             return ( usesreg != PC ? autoinc : immediate );
  84         case 9:
  85             return ( usesreg != PC ? autoincdef : absolute );
  86         case 10:
  87             return ( usesreg != PC ? bytedisp : byterel );
  88         case 11:
  89             return ( usesreg != PC ? bytedispdef : bytereldef );
  90         case 12:
  91             return ( usesreg != PC ? worddisp : wordrel );
  92         case 13:
  93             return ( usesreg != PC ? worddispdef : wordreldef );
  94         case 14:
  95             return ( usesreg != PC ? longdisp : longrel );
  96         case 15:
  97             return ( usesreg != PC ? longdispdef : longreldef );
  98     }
  99     /* NOTREACHED */
 100 }
 101
 102 char *
 103 operandname( mode )
 104     operandenum mode;
 105 {
 106
 107     switch ( mode ) {
 108         case literal:
 109             return "literal";
 110         case indexed:
 111             return "indexed";
 112         case reg:
 113             return "register";
 114         case regdef:
 115             return "register deferred";
 116         case autodec:
 117             return "autodecrement";
 118         case autoinc:
 119             return "autoincrement";
 120         case autoincdef:
 121             return "autoincrement deferred";
 122         case bytedisp:
 123             return "byte displacement";
 124         case bytedispdef:
 125             return "byte displacement deferred";
 126         case byterel:
 127             return "byte relative";
 128         case bytereldef:
 129             return "byte relative deferred";
 130         case worddisp:
 131             return "word displacement";
 132         case worddispdef:
 133             return "word displacement deferred";
 134         case wordrel:
 135             return "word relative";
 136         case wordreldef:
 137             return "word relative deferred";
 138         case immediate:
 139             return "immediate";
 140         case absolute:
 141             return "absolute";
 142         case longdisp:
 143             return "long displacement";
 144         case longdispdef:
 145             return "long displacement deferred";
 146         case longrel:
 147             return "long relative";
 148         case longreldef:
 149             return "long relative deferred";
 150     }
 151     /* NOTREACHED */
 152 }
 153
 154 long
 155 operandlength( modep )
 156     struct modebyte     *modep;
 157 {
 158
 159     switch ( operandmode( modep ) ) {
 160         case literal:
 161         case reg:
 162         case regdef:
 163         case autodec:
 164         case autoinc:
 165         case autoincdef:
 166             return 1;
 167         case bytedisp:
 168         case bytedispdef:
 169         case byterel:
 170         case bytereldef:
 171             return 2;
 172         case worddisp:
 173         case worddispdef:
 174         case wordrel:
 175         case wordreldef:
 176             return 3;
 177         case immediate:
 178         case absolute:
 179         case longdisp:
 180         case longdispdef:
 181         case longrel:
 182         case longreldef:
 183             return 5;
 184         case indexed:
 185             return 1+operandlength( (struct modebyte *) ((char *) modep) + 1 );
 186     }
 187     /* NOTREACHED */
 188 }
 189
 190 unsigned long
 191 reladdr( modep )
 192     struct modebyte     *modep;
 193 {
 194     operandenum mode = operandmode( modep );
 195     char        *cp;
 196     short       *sp;
 197     long        *lp;
 198
 199     cp = (char *) modep;
 200     cp += 1;                    /* skip over the mode */
 201     switch ( mode ) {
 202         default:
 203             fprintf( stderr , "[reladdr] not relative address\n" );
 204             return (unsigned long) modep;
 205         case byterel:
 206             return (unsigned long) ( cp + sizeof *cp + *cp );
 207         case wordrel:
 208             sp = (short *) cp;
 209             return (unsigned long) ( cp + sizeof *sp + *sp );
 210         case longrel:
 211             lp = (long *) cp;
 212             return (unsigned long) ( cp + sizeof *lp + *lp );
 213     }
 214 }
 215
 216 findcall( parentp , p_lowpc , p_highpc )
 217     nltype              *parentp;
 218     unsigned long       p_lowpc;
 219     unsigned long       p_highpc;
 220 {
 221     unsigned char       *instructp;
 222     long                length;
 223     nltype              *childp;
 224     operandenum         mode;
 225     operandenum         firstmode;
 226     unsigned long       destpc;
 227
 228     if ( textspace == 0 ) {
 229         return;
 230     }
 231     if ( p_lowpc < s_lowpc ) {
 232         p_lowpc = s_lowpc;
 233     }
 234     if ( p_highpc > s_highpc ) {
 235         p_highpc = s_highpc;
 236     }
 237 #   ifdef DEBUG
 238         if ( debug & CALLDEBUG ) {
 239             printf( "[findcall] %s: 0x%x to 0x%x\n" ,
 240                     parentp -> name , p_lowpc , p_highpc );
 241         }
 242 #   endif DEBUG
 243     for (   instructp = textspace + p_lowpc ;
 244             instructp < textspace + p_highpc ;
 245             instructp += length ) {
 246         length = 1;
 247         if ( *instructp == CALLS ) {
 248                 /*
 249                  *      maybe a calls, better check it out.
 250                  *      skip the count of the number of arguments.
 251                  */
 252 #           ifdef DEBUG
 253                 if ( debug & CALLDEBUG ) {
 254                     printf( "[findcall]\t0x%x:calls" , instructp - textspace );
 255                 }
 256 #           endif DEBUG
 257             firstmode = operandmode( (struct modebyte *) (instructp+length) );
 258             switch ( firstmode ) {
 259                 case literal:
 260                 case immediate:
 261                     break;
 262                 default:
 263                     goto botched;
 264             }
 265             length += operandlength( (struct modebyte *) (instructp+length) );
 266             mode = operandmode( (struct modebyte *) ( instructp + length ) );
 267 #           ifdef DEBUG
 268                 if ( debug & CALLDEBUG ) {
 269                     printf( "\tfirst operand is %s", operandname( firstmode ) );
 270                     printf( "\tsecond operand is %s\n" , operandname( mode ) );
 271                 }
 272 #           endif DEBUG
 273             switch ( mode ) {
 274                 case regdef:
 275                 case bytedispdef:
 276                 case worddispdef:
 277                 case longdispdef:
 278                 case bytereldef:
 279                 case wordreldef:
 280                 case longreldef:
 281                         /*
 282                          *      indirect call: call through pointer
 283                          *      either  *d(r)   as a parameter or local
 284                          *              (r)     as a return value
 285                          *              *f      as a global pointer
 286                          *      [are there others that we miss?,
 287                          *       e.g. arrays of pointers to functions???]
 288                          */
 289                     addarc( parentp , &indirectchild , (long) 0 );
 290                     length += operandlength(
 291                                 (struct modebyte *) ( instructp + length ) );
 292                     continue;
 293                 case byterel:
 294                 case wordrel:
 295                 case longrel:
 296                         /*
 297                          *      regular pc relative addressing
 298                          *      check that this is the address of
 299                          *      a function.
 300                          */
 301                     destpc = reladdr( (struct modebyte *) (instructp+length) )
 302                                 - (unsigned long) textspace;
 303                     if ( destpc >= s_lowpc && destpc <= s_highpc ) {
 304                         childp = nllookup( destpc );
 305 #                       ifdef DEBUG
 306                             if ( debug & CALLDEBUG ) {
 307                                 printf( "[findcall]\tdestpc 0x%x" , destpc );
 308                                 printf( " childp->name %s" , childp -> name );
 309                                 printf( " childp->value 0x%x\n" ,
 310                                         childp -> value );
 311                             }
 312 #                       endif DEBUG
 313                         if ( childp -> value == destpc ) {
 314                                 /*
 315                                  *      a hit
 316                                  */
 317                             addarc( parentp , childp , (long) 0 );
 318                             length += operandlength( (struct modebyte *)
 319                                             ( instructp + length ) );
 320                             continue;
 321                         }
 322                         goto botched;
 323                     }
 324                         /*
 325                          *      else:
 326                          *      it looked like a calls,
 327                          *      but it wasn't to anywhere.
 328                          */
 329                     goto botched;
 330                 default:
 331                 botched:
 332                         /*
 333                          *      something funny going on.
 334                          */
 335 #                   ifdef DEBUG
 336                         if ( debug & CALLDEBUG ) {
 337                             printf( "[findcall]\tbut it's a botch\n" );
 338                         }
 339 #                   endif DEBUG
 340                     length = 1;
 341                     continue;
 342             }
 343         }
 344     }
 345 }