Commit | Line | Data |
---|---|---|
45fe57e7 AT |
1 | /* Common target-dependent code for ppc64 GDB, the GNU debugger. |
2 | ||
3 | Copyright (C) 1986-2013 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
20 | #include "defs.h" | |
21 | #include "frame.h" | |
22 | #include "gdbcore.h" | |
23 | #include "ppc-tdep.h" | |
24 | #include "ppc64-tdep.h" | |
24c274a1 | 25 | #include "elf-bfd.h" |
45fe57e7 AT |
26 | |
27 | /* Macros for matching instructions. Note that, since all the | |
28 | operands are masked off before they're or-ed into the instruction, | |
29 | you can use -1 to make masks. */ | |
30 | ||
31 | #define insn_d(opcd, rts, ra, d) \ | |
32 | ((((opcd) & 0x3f) << 26) \ | |
33 | | (((rts) & 0x1f) << 21) \ | |
34 | | (((ra) & 0x1f) << 16) \ | |
35 | | ((d) & 0xffff)) | |
36 | ||
37 | #define insn_ds(opcd, rts, ra, d, xo) \ | |
38 | ((((opcd) & 0x3f) << 26) \ | |
39 | | (((rts) & 0x1f) << 21) \ | |
40 | | (((ra) & 0x1f) << 16) \ | |
41 | | ((d) & 0xfffc) \ | |
42 | | ((xo) & 0x3)) | |
43 | ||
44 | #define insn_xfx(opcd, rts, spr, xo) \ | |
45 | ((((opcd) & 0x3f) << 26) \ | |
46 | | (((rts) & 0x1f) << 21) \ | |
47 | | (((spr) & 0x1f) << 16) \ | |
48 | | (((spr) & 0x3e0) << 6) \ | |
49 | | (((xo) & 0x3ff) << 1)) | |
50 | ||
51 | /* If DESC is the address of a 64-bit PowerPC FreeBSD function | |
52 | descriptor, return the descriptor's entry point. */ | |
53 | ||
54 | static CORE_ADDR | |
55 | ppc64_desc_entry_point (struct gdbarch *gdbarch, CORE_ADDR desc) | |
56 | { | |
57 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
58 | /* The first word of the descriptor is the entry point. */ | |
59 | return (CORE_ADDR) read_memory_unsigned_integer (desc, 8, byte_order); | |
60 | } | |
61 | ||
62 | /* Pattern for the standard linkage function. These are built by | |
63 | build_plt_stub in elf64-ppc.c, whose GLINK argument is always | |
64 | zero. */ | |
65 | ||
66 | static struct ppc_insn_pattern ppc64_standard_linkage1[] = | |
67 | { | |
68 | /* addis r12, r2, <any> */ | |
69 | { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 }, | |
70 | ||
71 | /* std r2, 40(r1) */ | |
72 | { -1, insn_ds (62, 2, 1, 40, 0), 0 }, | |
73 | ||
74 | /* ld r11, <any>(r12) */ | |
75 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, | |
76 | ||
77 | /* addis r12, r12, 1 <optional> */ | |
78 | { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, | |
79 | ||
80 | /* ld r2, <any>(r12) */ | |
81 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, | |
82 | ||
83 | /* addis r12, r12, 1 <optional> */ | |
84 | { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, | |
85 | ||
86 | /* mtctr r11 */ | |
87 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
88 | ||
89 | /* ld r11, <any>(r12) <optional> */ | |
90 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, | |
91 | ||
92 | /* bctr */ | |
93 | { -1, 0x4e800420, 0 }, | |
94 | ||
95 | { 0, 0, 0 } | |
96 | }; | |
97 | ||
98 | #define PPC64_STANDARD_LINKAGE1_LEN ARRAY_SIZE (ppc64_standard_linkage1) | |
99 | ||
100 | static struct ppc_insn_pattern ppc64_standard_linkage2[] = | |
101 | { | |
102 | /* addis r12, r2, <any> */ | |
103 | { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 }, | |
104 | ||
105 | /* std r2, 40(r1) */ | |
106 | { -1, insn_ds (62, 2, 1, 40, 0), 0 }, | |
107 | ||
108 | /* ld r11, <any>(r12) */ | |
109 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, | |
110 | ||
111 | /* addi r12, r12, <any> <optional> */ | |
112 | { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 }, | |
113 | ||
114 | /* mtctr r11 */ | |
115 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
116 | ||
117 | /* ld r2, <any>(r12) */ | |
118 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, | |
119 | ||
120 | /* ld r11, <any>(r12) <optional> */ | |
121 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, | |
122 | ||
123 | /* bctr */ | |
124 | { -1, 0x4e800420, 0 }, | |
125 | ||
126 | { 0, 0, 0 } | |
127 | }; | |
128 | ||
129 | #define PPC64_STANDARD_LINKAGE2_LEN ARRAY_SIZE (ppc64_standard_linkage2) | |
130 | ||
131 | static struct ppc_insn_pattern ppc64_standard_linkage3[] = | |
132 | { | |
133 | /* std r2, 40(r1) */ | |
134 | { -1, insn_ds (62, 2, 1, 40, 0), 0 }, | |
135 | ||
136 | /* ld r11, <any>(r2) */ | |
137 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 }, | |
138 | ||
139 | /* addi r2, r2, <any> <optional> */ | |
140 | { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 }, | |
141 | ||
142 | /* mtctr r11 */ | |
143 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
144 | ||
145 | /* ld r11, <any>(r2) <optional> */ | |
146 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 }, | |
147 | ||
148 | /* ld r2, <any>(r2) */ | |
149 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 }, | |
150 | ||
151 | /* bctr */ | |
152 | { -1, 0x4e800420, 0 }, | |
153 | ||
154 | { 0, 0, 0 } | |
155 | }; | |
156 | ||
157 | #define PPC64_STANDARD_LINKAGE3_LEN ARRAY_SIZE (ppc64_standard_linkage3) | |
158 | ||
159 | /* When the dynamic linker is doing lazy symbol resolution, the first | |
160 | call to a function in another object will go like this: | |
161 | ||
162 | - The user's function calls the linkage function: | |
163 | ||
164 | 100007c4: 4b ff fc d5 bl 10000498 | |
165 | 100007c8: e8 41 00 28 ld r2,40(r1) | |
166 | ||
167 | - The linkage function loads the entry point (and other stuff) from | |
168 | the function descriptor in the PLT, and jumps to it: | |
169 | ||
170 | 10000498: 3d 82 00 00 addis r12,r2,0 | |
171 | 1000049c: f8 41 00 28 std r2,40(r1) | |
172 | 100004a0: e9 6c 80 98 ld r11,-32616(r12) | |
173 | 100004a4: e8 4c 80 a0 ld r2,-32608(r12) | |
174 | 100004a8: 7d 69 03 a6 mtctr r11 | |
175 | 100004ac: e9 6c 80 a8 ld r11,-32600(r12) | |
176 | 100004b0: 4e 80 04 20 bctr | |
177 | ||
178 | - But since this is the first time that PLT entry has been used, it | |
179 | sends control to its glink entry. That loads the number of the | |
180 | PLT entry and jumps to the common glink0 code: | |
181 | ||
182 | 10000c98: 38 00 00 00 li r0,0 | |
183 | 10000c9c: 4b ff ff dc b 10000c78 | |
184 | ||
185 | - The common glink0 code then transfers control to the dynamic | |
186 | linker's fixup code: | |
187 | ||
188 | 10000c78: e8 41 00 28 ld r2,40(r1) | |
189 | 10000c7c: 3d 82 00 00 addis r12,r2,0 | |
190 | 10000c80: e9 6c 80 80 ld r11,-32640(r12) | |
191 | 10000c84: e8 4c 80 88 ld r2,-32632(r12) | |
192 | 10000c88: 7d 69 03 a6 mtctr r11 | |
193 | 10000c8c: e9 6c 80 90 ld r11,-32624(r12) | |
194 | 10000c90: 4e 80 04 20 bctr | |
195 | ||
196 | Eventually, this code will figure out how to skip all of this, | |
197 | including the dynamic linker. At the moment, we just get through | |
198 | the linkage function. */ | |
199 | ||
200 | /* If the current thread is about to execute a series of instructions | |
201 | at PC matching the ppc64_standard_linkage pattern, and INSN is the result | |
202 | from that pattern match, return the code address to which the | |
203 | standard linkage function will send them. (This doesn't deal with | |
204 | dynamic linker lazy symbol resolution stubs.) */ | |
205 | ||
206 | static CORE_ADDR | |
207 | ppc64_standard_linkage1_target (struct frame_info *frame, | |
208 | CORE_ADDR pc, unsigned int *insn) | |
209 | { | |
210 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
211 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
212 | ||
213 | /* The address of the function descriptor this linkage function | |
214 | references. */ | |
215 | CORE_ADDR desc | |
216 | = ((CORE_ADDR) get_frame_register_unsigned (frame, | |
217 | tdep->ppc_gp0_regnum + 2) | |
218 | + (ppc_insn_d_field (insn[0]) << 16) | |
219 | + ppc_insn_ds_field (insn[2])); | |
220 | ||
221 | /* The first word of the descriptor is the entry point. Return that. */ | |
222 | return ppc64_desc_entry_point (gdbarch, desc); | |
223 | } | |
224 | ||
225 | static CORE_ADDR | |
226 | ppc64_standard_linkage2_target (struct frame_info *frame, | |
227 | CORE_ADDR pc, unsigned int *insn) | |
228 | { | |
229 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
230 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
231 | ||
232 | /* The address of the function descriptor this linkage function | |
233 | references. */ | |
234 | CORE_ADDR desc | |
235 | = ((CORE_ADDR) get_frame_register_unsigned (frame, | |
236 | tdep->ppc_gp0_regnum + 2) | |
237 | + (ppc_insn_d_field (insn[0]) << 16) | |
238 | + ppc_insn_ds_field (insn[2])); | |
239 | ||
240 | /* The first word of the descriptor is the entry point. Return that. */ | |
241 | return ppc64_desc_entry_point (gdbarch, desc); | |
242 | } | |
243 | ||
244 | static CORE_ADDR | |
245 | ppc64_standard_linkage3_target (struct frame_info *frame, | |
246 | CORE_ADDR pc, unsigned int *insn) | |
247 | { | |
248 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
249 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
250 | ||
251 | /* The address of the function descriptor this linkage function | |
252 | references. */ | |
253 | CORE_ADDR desc | |
254 | = ((CORE_ADDR) get_frame_register_unsigned (frame, | |
255 | tdep->ppc_gp0_regnum + 2) | |
256 | + ppc_insn_ds_field (insn[1])); | |
257 | ||
258 | /* The first word of the descriptor is the entry point. Return that. */ | |
259 | return ppc64_desc_entry_point (gdbarch, desc); | |
260 | } | |
261 | ||
262 | ||
263 | /* Given that we've begun executing a call trampoline at PC, return | |
264 | the entry point of the function the trampoline will go to. */ | |
265 | ||
266 | CORE_ADDR | |
267 | ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) | |
268 | { | |
269 | unsigned int ppc64_standard_linkage1_insn[PPC64_STANDARD_LINKAGE1_LEN]; | |
270 | unsigned int ppc64_standard_linkage2_insn[PPC64_STANDARD_LINKAGE2_LEN]; | |
271 | unsigned int ppc64_standard_linkage3_insn[PPC64_STANDARD_LINKAGE3_LEN]; | |
272 | CORE_ADDR target; | |
273 | ||
274 | if (ppc_insns_match_pattern (pc, ppc64_standard_linkage1, | |
275 | ppc64_standard_linkage1_insn)) | |
276 | pc = ppc64_standard_linkage1_target (frame, pc, | |
277 | ppc64_standard_linkage1_insn); | |
278 | else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage2, | |
279 | ppc64_standard_linkage2_insn)) | |
280 | pc = ppc64_standard_linkage2_target (frame, pc, | |
281 | ppc64_standard_linkage2_insn); | |
282 | else if (ppc_insns_match_pattern (pc, ppc64_standard_linkage3, | |
283 | ppc64_standard_linkage3_insn)) | |
284 | pc = ppc64_standard_linkage3_target (frame, pc, | |
285 | ppc64_standard_linkage3_insn); | |
286 | else | |
287 | return 0; | |
288 | ||
289 | /* The PLT descriptor will either point to the already resolved target | |
290 | address, or else to a glink stub. As the latter carry synthetic @plt | |
291 | symbols, find_solib_trampoline_target should be able to resolve them. */ | |
292 | target = find_solib_trampoline_target (frame, pc); | |
293 | return target ? target : pc; | |
294 | } | |
295 | ||
296 | /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64 | |
297 | GNU/Linux. | |
298 | ||
299 | Usually a function pointer's representation is simply the address | |
300 | of the function. On GNU/Linux on the PowerPC however, a function | |
301 | pointer may be a pointer to a function descriptor. | |
302 | ||
303 | For PPC64, a function descriptor is a TOC entry, in a data section, | |
304 | which contains three words: the first word is the address of the | |
305 | function, the second word is the TOC pointer (r2), and the third word | |
306 | is the static chain value. | |
307 | ||
308 | Throughout GDB it is currently assumed that a function pointer contains | |
309 | the address of the function, which is not easy to fix. In addition, the | |
310 | conversion of a function address to a function pointer would | |
311 | require allocation of a TOC entry in the inferior's memory space, | |
312 | with all its drawbacks. To be able to call C++ virtual methods in | |
313 | the inferior (which are called via function pointers), | |
314 | find_function_addr uses this function to get the function address | |
315 | from a function pointer. | |
316 | ||
317 | If ADDR points at what is clearly a function descriptor, transform | |
318 | it into the address of the corresponding function, if needed. Be | |
319 | conservative, otherwise GDB will do the transformation on any | |
320 | random addresses such as occur when there is no symbol table. */ | |
321 | ||
322 | CORE_ADDR | |
323 | ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, | |
324 | CORE_ADDR addr, | |
325 | struct target_ops *targ) | |
326 | { | |
327 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
328 | struct target_section *s = target_section_by_addr (targ, addr); | |
329 | ||
330 | /* Check if ADDR points to a function descriptor. */ | |
331 | if (s && strcmp (s->the_bfd_section->name, ".opd") == 0) | |
332 | { | |
333 | /* There may be relocations that need to be applied to the .opd | |
334 | section. Unfortunately, this function may be called at a time | |
335 | where these relocations have not yet been performed -- this can | |
336 | happen for example shortly after a library has been loaded with | |
337 | dlopen, but ld.so has not yet applied the relocations. | |
338 | ||
339 | To cope with both the case where the relocation has been applied, | |
340 | and the case where it has not yet been applied, we do *not* read | |
341 | the (maybe) relocated value from target memory, but we instead | |
342 | read the non-relocated value from the BFD, and apply the relocation | |
343 | offset manually. | |
344 | ||
345 | This makes the assumption that all .opd entries are always relocated | |
346 | by the same offset the section itself was relocated. This should | |
347 | always be the case for GNU/Linux executables and shared libraries. | |
348 | Note that other kind of object files (e.g. those added via | |
349 | add-symbol-files) will currently never end up here anyway, as this | |
350 | function accesses *target* sections only; only the main exec and | |
351 | shared libraries are ever added to the target. */ | |
352 | ||
353 | gdb_byte buf[8]; | |
354 | int res; | |
355 | ||
356 | res = bfd_get_section_contents (s->bfd, s->the_bfd_section, | |
357 | &buf, addr - s->addr, 8); | |
358 | if (res != 0) | |
359 | return extract_unsigned_integer (buf, 8, byte_order) | |
360 | - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr; | |
361 | } | |
362 | ||
363 | return addr; | |
364 | } | |
24c274a1 AM |
365 | |
366 | /* A synthetic 'dot' symbols on ppc64 has the udata.p entry pointing | |
367 | back to the original ELF symbol it was derived from. Get the size | |
368 | from that symbol. */ | |
369 | ||
370 | void | |
371 | ppc64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) | |
372 | { | |
373 | if ((sym->flags & BSF_SYNTHETIC) != 0 && sym->udata.p != NULL) | |
374 | { | |
375 | elf_symbol_type *elf_sym = (elf_symbol_type *) sym->udata.p; | |
376 | SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size); | |
377 | } | |
378 | } |