gprof/alpha.c

   1 /*
   2  * Copyright (c) 1983, 1998 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 "corefile.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         int disp:21;
  47         unsigned ra:5;
  48         unsigned op_code:6;
  49       }
  50     b;                          /* branch format */
  51     struct
  52       {
  53         int 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 alpha_Instruction;
  62
  63 static Sym indirect_child;
  64
  65 void alpha_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
  66
  67 /*
  68  * On the Alpha we can only detect PC relative calls, which are
  69  * usually generated for calls to functions within the same
  70  * object file only.  This is still better than nothing, however.
  71  * (In particular it should be possible to find functions that
  72  *  potentially call integer division routines, for example.)
  73  */
  74 void
  75 alpha_find_call (parent, p_lowpc, p_highpc)
  76      Sym *parent;
  77      bfd_vma p_lowpc;
  78      bfd_vma p_highpc;
  79 {
  80   static bfd_vma delta = 0;
  81   bfd_vma dest_pc;
  82   alpha_Instruction *pc;
  83   Sym *child;
  84
  85   if (!delta)
  86     {
  87       delta = (bfd_vma) core_text_space - core_text_sect->vma;
  88
  89       sym_init (&indirect_child);
  90       indirect_child.name = _("<indirect child>");
  91       indirect_child.cg.prop.fract = 1.0;
  92       indirect_child.cg.cyc.head = &indirect_child;
  93     }
  94
  95   if (!core_text_space)
  96     {
  97       return;
  98     }
  99   if (p_lowpc < s_lowpc)
 100     {
 101       p_lowpc = s_lowpc;
 102     }
 103   if (p_highpc > s_highpc)
 104     {
 105       p_highpc = s_highpc;
 106     }
 107   DBG (CALLDEBUG, printf (_("[find_call] %s: 0x%lx to 0x%lx\n"),
 108                           parent->name, (unsigned long) p_lowpc,
 109                           (unsigned long) p_highpc));
 110   for (pc = (alpha_Instruction *) (p_lowpc + delta);
 111        pc < (alpha_Instruction *) (p_highpc + delta);
 112        ++pc)
 113     {
 114       switch (pc->a.op_code)
 115         {
 116         case OP_Jxx:
 117           /*
 118            * There is no simple and reliable way to determine the
 119            * target of a jsr (the hint bits help, but there aren't
 120            * enough bits to get a satisfactory hit rate).  Instead,
 121            * for any indirect jump we simply add an arc from PARENT
 122            * to INDIRECT_CHILD---that way the user it at least able
 123            * to see that there are other calls as well.
 124            */
 125           if (pc->j.func == Jxx_FUNC_JSR
 126               || pc->j.func == Jxx_FUNC_JSR_COROUTINE)
 127             {
 128               DBG (CALLDEBUG,
 129                    printf (_("[find_call] 0x%lx: jsr%s <indirect_child>\n"),
 130                            (unsigned long) pc - delta,
 131                            pc->j.func == Jxx_FUNC_JSR ? "" : "_coroutine"));
 132               arc_add (parent, &indirect_child, (unsigned long) 0);
 133             }
 134           break;
 135
 136         case OP_BSR:
 137           DBG (CALLDEBUG,
 138                printf (_("[find_call] 0x%lx: bsr"),
 139                        (unsigned long) pc - delta));
 140           /*
 141            * Regular PC relative addressing.  Check that this is the
 142            * address of a function.  The linker sometimes redirects
 143            * the entry point by 8 bytes to skip loading the global
 144            * pointer, so we all for either address:
 145            */
 146           dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
 147           if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
 148             {
 149               child = sym_lookup (&symtab, dest_pc);
 150               DBG (CALLDEBUG,
 151                    printf (" 0x%lx\t; name=%s, addr=0x%lx",
 152                            (unsigned long) dest_pc, child->name,
 153                            (unsigned long) child->addr));
 154               if (child->addr == dest_pc || child->addr == dest_pc - 8)
 155                 {
 156                   DBG (CALLDEBUG, printf ("\n"));
 157                   /* a hit:  */
 158                   arc_add (parent, child, (unsigned long) 0);
 159                   continue;
 160                 }
 161             }
 162           /*
 163            * Something funny going on.
 164            */
 165           DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
 166           break;
 167
 168         default:
 169           break;
 170         }
 171     }
 172 }