This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / 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 }