contrib/binutils-2.22/gprof/tahoe.c

   1 /*
   2  * Copyright (c) 1983, 1993, 2001
   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. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 #include "gprof.h"
  30 #include "search_list.h"
  31 #include "source.h"
  32 #include "symtab.h"
  33 #include "cg_arcs.h"
  34 #include "corefile.h"
  35 #include "hist.h"
  36
  37     /*
  38      *        opcode of the `callf' instruction
  39      */
  40 #define CALLF   0xfe
  41
  42     /*
  43      *        register for pc relative addressing
  44      */
  45 #define PC      0xf
  46
  47 enum tahoe_opermodes
  48   {
  49     literal, indexed, reg, regdef, autodec, autoinc, autoincdef,
  50     bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,
  51     immediate, absolute, byterel, bytereldef, wordrel, wordreldef,
  52     longrel, longreldef
  53   };
  54 typedef enum tahoe_opermodes tahoe_operandenum;
  55
  56 /*
  57  * A symbol to be the child of indirect callf:
  58  */
  59 static Sym indirectchild;
  60
  61 static tahoe_operandenum tahoe_operandmode (unsigned char *);
  62 static char *tahoe_operandname (tahoe_operandenum);
  63 static long tahoe_operandlength (unsigned char *);
  64 static bfd_signed_vma tahoe_offset (unsigned char *);
  65 void tahoe_find_call (Sym *, bfd_vma, bfd_vma);
  66
  67 static tahoe_operandenum
  68 tahoe_operandmode (unsigned char *modep)
  69 {
  70   long usesreg = *modep & 0xf;
  71
  72   switch ((*modep >> 4) & 0xf)
  73     {
  74     case 0:
  75     case 1:
  76     case 2:
  77     case 3:
  78       return literal;
  79     case 4:
  80       return indexed;
  81     case 5:
  82       return reg;
  83     case 6:
  84       return regdef;
  85     case 7:
  86       return autodec;
  87     case 8:
  88       return usesreg != 0xe ? autoinc : immediate;
  89     case 9:
  90       return usesreg != PC ? autoincdef : absolute;
  91     case 10:
  92       return usesreg != PC ? bytedisp : byterel;
  93     case 11:
  94       return usesreg != PC ? bytedispdef : bytereldef;
  95     case 12:
  96       return usesreg != PC ? worddisp : wordrel;
  97     case 13:
  98       return usesreg != PC ? worddispdef : wordreldef;
  99     case 14:
 100       return usesreg != PC ? longdisp : longrel;
 101     case 15:
 102       return usesreg != PC ? longdispdef : longreldef;
 103     }
 104   /* NOTREACHED */
 105   abort ();
 106 }
 107
 108 static char *
 109 tahoe_operandname (tahoe_operandenum mode)
 110 {
 111
 112   switch (mode)
 113     {
 114     case literal:
 115       return "literal";
 116     case indexed:
 117       return "indexed";
 118     case reg:
 119       return "register";
 120     case regdef:
 121       return "register deferred";
 122     case autodec:
 123       return "autodecrement";
 124     case autoinc:
 125       return "autoincrement";
 126     case autoincdef:
 127       return "autoincrement deferred";
 128     case bytedisp:
 129       return "byte displacement";
 130     case bytedispdef:
 131       return "byte displacement deferred";
 132     case byterel:
 133       return "byte relative";
 134     case bytereldef:
 135       return "byte relative deferred";
 136     case worddisp:
 137       return "word displacement";
 138     case worddispdef:
 139       return "word displacement deferred";
 140     case wordrel:
 141       return "word relative";
 142     case wordreldef:
 143       return "word relative deferred";
 144     case immediate:
 145       return "immediate";
 146     case absolute:
 147       return "absolute";
 148     case longdisp:
 149       return "long displacement";
 150     case longdispdef:
 151       return "long displacement deferred";
 152     case longrel:
 153       return "long relative";
 154     case longreldef:
 155       return "long relative deferred";
 156     }
 157   /* NOTREACHED */
 158   abort ();
 159 }
 160
 161 static long
 162 tahoe_operandlength (unsigned char *modep
 163 )
 164 {
 165
 166   switch (tahoe_operandmode (modep))
 167     {
 168     case literal:
 169     case reg:
 170     case regdef:
 171     case autodec:
 172     case autoinc:
 173     case autoincdef:
 174       return 1;
 175     case bytedisp:
 176     case bytedispdef:
 177     case byterel:
 178     case bytereldef:
 179       return 2;
 180     case worddisp:
 181     case worddispdef:
 182     case wordrel:
 183     case wordreldef:
 184       return 3;
 185     case immediate:
 186     case absolute:
 187     case longdisp:
 188     case longdispdef:
 189     case longrel:
 190     case longreldef:
 191       return 5;
 192     case indexed:
 193       return 1 + tahoe_operandlength (modep + 1);
 194     }
 195   /* NOTREACHED */
 196   abort ();
 197 }
 198
 199 static bfd_signed_vma
 200 tahoe_offset (unsigned char *modep)
 201 {
 202   tahoe_operandenum mode = tahoe_operandmode (modep);
 203
 204   ++modep;                              /* skip over the mode */
 205   switch (mode)
 206     {
 207     default:
 208       fprintf (stderr, "[reladdr] not relative address\n");
 209       return 0;
 210     case byterel:
 211       return 1 + bfd_get_signed_8 (core_bfd, modep);
 212     case wordrel:
 213       return 2 + bfd_get_signed_16 (core_bfd, modep);
 214     case longrel:
 215       return 4 + bfd_get_signed_32 (core_bfd, modep);
 216     }
 217 }
 218
 219 void
 220 tahoe_find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
 221 {
 222   unsigned char *instructp;
 223   long length;
 224   Sym *child;
 225   tahoe_operandenum mode;
 226   tahoe_operandenum firstmode;
 227   bfd_vma pc, destpc;
 228   static bfd_boolean inited = FALSE;
 229
 230   if (!inited)
 231     {
 232       inited = TRUE;
 233       sym_init (&indirectchild);
 234       indirectchild.cg.prop.fract = 1.0;
 235       indirectchild.cg.cyc.head = &indirectchild;
 236     }
 237
 238   DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",
 239                           parent->name, (unsigned long) p_lowpc,
 240                           (unsigned long) p_highpc));
 241   for (pc = p_lowpc; pc < p_highpc; pc += length)
 242     {
 243       length = 1;
 244       instructp = ((unsigned char *) core_text_space
 245                    + pc - core_text_sect->vma);
 246       if ((*instructp & 0xff) == CALLF)
 247         {
 248           /*
 249            *    maybe a callf, better check it out.
 250            *      skip the count of the number of arguments.
 251            */
 252           DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",
 253                                   (unsigned long) pc));
 254           firstmode = tahoe_operandmode (instructp + length);
 255           switch (firstmode)
 256             {
 257             case literal:
 258             case immediate:
 259               break;
 260             default:
 261               goto botched;
 262             }
 263           length += tahoe_operandlength (instructp + length);
 264           mode = tahoe_operandmode (instructp + length);
 265           DBG (CALLDEBUG,
 266                printf ("\tfirst operand is %s", tahoe_operandname (firstmode));
 267                printf ("\tsecond operand is %s\n", tahoe_operandname (mode));
 268             );
 269           switch (mode)
 270             {
 271             case regdef:
 272             case bytedispdef:
 273             case worddispdef:
 274             case longdispdef:
 275             case bytereldef:
 276             case wordreldef:
 277             case longreldef:
 278               /*
 279                *    indirect call: call through pointer
 280                *      either  *d(r)   as a parameter or local
 281                *              (r)     as a return value
 282                *              *f      as a global pointer
 283                *      [are there others that we miss?,
 284                *       e.g. arrays of pointers to functions???]
 285                */
 286               arc_add (parent, &indirectchild, (unsigned long) 0);
 287               length += tahoe_operandlength (instructp + length);
 288               continue;
 289             case byterel:
 290             case wordrel:
 291             case longrel:
 292               /*
 293                *    regular pc relative addressing
 294                *      check that this is the address of
 295                *      a function.
 296                */
 297               destpc = pc + tahoe_offset (instructp + length);
 298               if (hist_check_address (destpc))
 299                 {
 300                   child = sym_lookup (&symtab, destpc);
 301                   if (child)
 302                     {
 303                       DBG (CALLDEBUG,
 304                            printf ("[findcall]\tdestpc 0x%lx",
 305                                    (unsigned long) destpc);
 306                            printf (" child->name %s", child->name);
 307                            printf (" child->addr 0x%lx\n",
 308                                    (unsigned long) child->addr);
 309                         );
 310                       if (child->addr == destpc)
 311                         {
 312                           /*
 313                            *    a hit
 314                            */
 315                           arc_add (parent, child, (unsigned long) 0);
 316                           length += tahoe_operandlength (instructp + length);
 317                           continue;
 318                         }
 319                     }
 320                   goto botched;
 321                 }
 322               /*
 323                *    else:
 324                *      it looked like a callf,
 325                *      but it wasn't to anywhere.
 326                */
 327               goto botched;
 328             default:
 329             botched:
 330               /*
 331                *    something funny going on.
 332                */
 333               DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));
 334               length = 1;
 335               continue;
 336             }
 337         }
 338     }
 339 }