gprof/alpha.c

   1 /*
   2  * Copyright (c) 1983 Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that: (1) source distributions retain this entire copyright
   7  * notice and comment, and (2) distributions including binaries display
   8  * the following acknowledgement:  ``This product includes software
   9  * developed by the University of California, Berkeley and its contributors''
  10  * in the documentation or other materials provided with the distribution
  11  * and in all advertising materials mentioning features or use of this
  12  * software. Neither the name of the University nor the names of its
  13  * contributors may be used to endorse or promote products derived
  14  * from this software without specific prior written permission.
  15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19 #include "gprof.h"
  20 #include "cg_arcs.h"
  21 #include "core.h"
  22 #include "hist.h"
  23 #include "symtab.h"
  24
  25 /*
  26  * Opcodes of the call instructions:
  27  */
  28 #define OP_Jxx  0x1a
  29 #define OP_BSR  0x34
  30
  31 #define Jxx_FUNC_JMP            0
  32 #define Jxx_FUNC_JSR            1
  33 #define Jxx_FUNC_RET            2
  34 #define Jxx_FUNC_JSR_COROUTINE  3
  35
  36 typedef union
  37   {
  38     struct
  39       {
  40         unsigned other:26;
  41         unsigned op_code:6;
  42       }
  43     a;                          /* any format */
  44     struct
  45       {
  46         signed disp:21;
  47         unsigned ra:5;
  48         unsigned op_code:6;
  49       }
  50     b;                          /* branch format */
  51     struct
  52       {
  53         signed hint:14;
  54         unsigned func:2;
  55         unsigned rb:5;
  56         unsigned ra:5;
  57         unsigned op_code:6;
  58       }
  59     j;                          /* jump format */
  60   }
  61 Instruction;
  62
  63 static Sym indirect_child;
  64
  65
  66 /*
  67  * On the Alpha we can only detect PC relative calls, which are
  68  * usually generated for calls to functions within the same
  69  * object file only.  This is still better than nothing, however.
  70  * (In particular it should be possible to find functions that
  71  *  potentially call integer division routines, for example.)
  72  */
  73 void
  74 find_call (parent, p_lowpc, p_highpc)
  75      Sym *parent;
  76      bfd_vma p_lowpc;
  77      bfd_vma p_highpc;
  78 {
  79   static bfd_vma delta = 0;
  80   bfd_vma dest_pc;
  81   Instruction *pc;
  82   Sym *child;
  83
  84   if (!delta)
  85     {
  86       delta = (bfd_vma) core_text_space - core_text_sect->vma;
  87
  88       sym_init (&indirect_child);
  89       indirect_child.name = "<indirect child>";
  90       indirect_child.cg.prop.fract = 1.0;
  91       indirect_child.cg.cyc.head = &indirect_child;
  92     }
  93
  94   if (!core_text_space)
  95     {
  96       return;
  97     }
  98   if (p_lowpc < s_lowpc)
  99     {
 100       p_lowpc = s_lowpc;
 101     }
 102   if (p_highpc > s_highpc)
 103     {
 104       p_highpc = s_highpc;
 105     }
 106   DBG (CALLDEBUG, printf ("[find_call] %s: 0x%lx to 0x%lx\n",
 107                           parent->name, p_lowpc, p_highpc));
 108   for (pc = (Instruction *) (p_lowpc + delta);
 109        pc < (Instruction *) (p_highpc + delta);
 110        ++pc)
 111     {
 112       switch (pc->a.op_code)
 113         {
 114         case OP_Jxx:
 115           /*
 116            * There is no simple and reliable way to determine the
 117            * target of a jsr (the hint bits help, but there aren't
 118            * enough bits to get a satisfactory hit rate).  Instead,
 119            * for any indirect jump we simply add an arc from PARENT
 120            * to INDIRECT_CHILD---that way the user it at least able
 121            * to see that there are other calls as well.
 122            */
 123           if (pc->j.func == Jxx_FUNC_JSR
 124               || pc->j.func == Jxx_FUNC_JSR_COROUTINE)
 125             {
 126               DBG (CALLDEBUG,
 127                    printf ("[find_call] 0x%lx: jsr%s <indirect_child>\n",
 128                            (bfd_vma) pc - delta,
 129                            pc->j.func == Jxx_FUNC_JSR ? "" : "_coroutine"));
 130               arc_add (parent, &indirect_child, 0);
 131             }
 132           break;
 133
 134         case OP_BSR:
 135           DBG (CALLDEBUG,
 136                printf ("[find_call] 0x%lx: bsr", (bfd_vma) pc - delta));
 137           /*
 138            * Regular PC relative addressing.  Check that this is the
 139            * address of a function.  The linker sometimes redirects
 140            * the entry point by 8 bytes to skip loading the global
 141            * pointer, so we all for either address:
 142            */
 143           dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
 144           if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
 145             {
 146               child = sym_lookup (&symtab, dest_pc);
 147               DBG (CALLDEBUG,
 148                    printf (" 0x%lx\t; name=%s, addr=0x%lx",
 149                            dest_pc, child->name, child->addr));
 150               if (child->addr == dest_pc || child->addr == dest_pc - 8)
 151                 {
 152                   DBG (CALLDEBUG, printf ("\n"));
 153                   /* a hit:  */
 154                   arc_add (parent, child, 0);
 155                   continue;
 156                 }
 157             }
 158           /*
 159            * Something funny going on.
 160            */
 161           DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
 162           break;
 163
 164         default:
 165           break;
 166         }
 167     }
 168 }