Commit | Line | Data |
---|---|---|
252b5132 RH |
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 | ||
5789ecea | 65 | void alpha_find_call PARAMS ((Sym *, bfd_vma, bfd_vma)); |
252b5132 RH |
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"), | |
fdcf7d43 ILT |
108 | parent->name, (unsigned long) p_lowpc, |
109 | (unsigned long) p_highpc)); | |
252b5132 RH |
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"), | |
55c80890 | 130 | (unsigned long) pc - (unsigned long) delta, |
252b5132 RH |
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, | |
fdcf7d43 | 138 | printf (_("[find_call] 0x%lx: bsr"), |
55c80890 | 139 | (unsigned long) pc - (unsigned long) delta)); |
252b5132 RH |
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", | |
fdcf7d43 ILT |
152 | (unsigned long) dest_pc, child->name, |
153 | (unsigned long) child->addr)); | |
252b5132 RH |
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 | } |