gdb/
[deliverable/binutils-gdb.git] / gdb / ppc64-tdep.c
CommitLineData
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
54static CORE_ADDR
55ppc64_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
66static 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
100static 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
131static 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
206static CORE_ADDR
207ppc64_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
225static CORE_ADDR
226ppc64_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
244static CORE_ADDR
245ppc64_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
266CORE_ADDR
267ppc64_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
322CORE_ADDR
323ppc64_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
370void
371ppc64_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}
This page took 0.091068 seconds and 4 git commands to generate.