Initial revision
[binutils.git] / gprof / alpha.c
blobad4f22e46741322c002ab324f81de7f4e6b74070
1 /*
2 * Copyright (c) 1983, 1998 Regents of the University of California.
3 * All rights reserved.
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.
19 #include "gprof.h"
20 #include "cg_arcs.h"
21 #include "corefile.h"
22 #include "hist.h"
23 #include "symtab.h"
26 * Opcodes of the call instructions:
28 #define OP_Jxx 0x1a
29 #define OP_BSR 0x34
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
36 typedef union
38 struct
40 unsigned other:26;
41 unsigned op_code:6;
43 a; /* any format */
44 struct
46 int disp:21;
47 unsigned ra:5;
48 unsigned op_code:6;
50 b; /* branch format */
51 struct
53 int hint:14;
54 unsigned func:2;
55 unsigned rb:5;
56 unsigned ra:5;
57 unsigned op_code:6;
59 j; /* jump format */
61 alpha_Instruction;
63 static Sym indirect_child;
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.)
73 void
74 alpha_find_call (parent, p_lowpc, p_highpc)
75 Sym *parent;
76 bfd_vma p_lowpc;
77 bfd_vma p_highpc;
79 static bfd_vma delta = 0;
80 bfd_vma dest_pc;
81 alpha_Instruction *pc;
82 Sym *child;
84 if (!delta)
86 delta = (bfd_vma) core_text_space - core_text_sect->vma;
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;
94 if (!core_text_space)
96 return;
98 if (p_lowpc < s_lowpc)
100 p_lowpc = s_lowpc;
102 if (p_highpc > s_highpc)
104 p_highpc = s_highpc;
106 DBG (CALLDEBUG, printf (_("[find_call] %s: 0x%lx to 0x%lx\n"),
107 parent->name, p_lowpc, p_highpc));
108 for (pc = (alpha_Instruction *) (p_lowpc + delta);
109 pc < (alpha_Instruction *) (p_highpc + delta);
110 ++pc)
112 switch (pc->a.op_code)
114 case OP_Jxx:
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.
123 if (pc->j.func == Jxx_FUNC_JSR
124 || pc->j.func == Jxx_FUNC_JSR_COROUTINE)
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, (unsigned long) 0);
132 break;
134 case OP_BSR:
135 DBG (CALLDEBUG,
136 printf (_("[find_call] 0x%lx: bsr"), (bfd_vma) pc - delta));
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:
143 dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
144 if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
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)
152 DBG (CALLDEBUG, printf ("\n"));
153 /* a hit: */
154 arc_add (parent, child, (unsigned long) 0);
155 continue;
159 * Something funny going on.
161 DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
162 break;
164 default:
165 break;