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
  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 alpha_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   alpha_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, (unsigned long) p_lowpc,
 108                           (unsigned long) p_highpc));
 109   for (pc = (alpha_Instruction *) (p_lowpc + delta);
 110        pc < (alpha_Instruction *) (p_highpc + delta);
 111        ++pc)
 112     {
 113       switch (pc->a.op_code)
 114         {
 115         case OP_Jxx:
 116           /*
 117            * There is no simple and reliable way to determine the
 118            * target of a jsr (the hint bits help, but there aren't
 119            * enough bits to get a satisfactory hit rate).  Instead,
 120            * for any indirect jump we simply add an arc from PARENT
 121            * to INDIRECT_CHILD---that way the user it at least able
 122            * to see that there are other calls as well.
 123            */
 124           if (pc->j.func == Jxx_FUNC_JSR
 125               || pc->j.func == Jxx_FUNC_JSR_COROUTINE)
 126             {
 127               DBG (CALLDEBUG,
 128                    printf (_("[find_call] 0x%lx: jsr%s <indirect_child>\n"),
 129                            (unsigned long) pc - delta,
 130                            pc->j.func == Jxx_FUNC_JSR ? "" : "_coroutine"));
 131               arc_add (parent, &indirect_child, (unsigned long) 0);
 132             }
 133           break;
 134
 135         case OP_BSR:
 136           DBG (CALLDEBUG,
 137                printf (_("[find_call] 0x%lx: bsr"),
 138                        (unsigned long) pc - delta));
 139           /*
 140            * Regular PC relative addressing.  Check that this is the
 141            * address of a function.  The linker sometimes redirects
 142            * the entry point by 8 bytes to skip loading the global
 143            * pointer, so we all for either address:
 144            */
 145           dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
 146           if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
 147             {
 148               child = sym_lookup (&symtab, dest_pc);
 149               DBG (CALLDEBUG,
 150                    printf (" 0x%lx\t; name=%s, addr=0x%lx",
 151                            (unsigned long) dest_pc, child->name,
 152                            (unsigned long) child->addr));
 153               if (child->addr == dest_pc || child->addr == dest_pc - 8)
 154                 {
 155                   DBG (CALLDEBUG, printf ("\n"));
 156                   /* a hit:  */
 157                   arc_add (parent, child, (unsigned long) 0);
 158                   continue;
 159                 }
 160             }
 161           /*
 162            * Something funny going on.
 163            */
 164           DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
 165           break;
 166
 167         default:
 168           break;
 169         }
 170     }
 171 }