1 /* Common target-dependent code for ppc64 GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #include "ppc64-tdep.h"
26 /* Macros for matching instructions. Note that, since all the
27 operands are masked off before they're or-ed into the instruction,
28 you can use -1 to make masks. */
30 #define insn_d(opcd, rts, ra, d) \
31 ((((opcd) & 0x3f) << 26) \
32 | (((rts) & 0x1f) << 21) \
33 | (((ra) & 0x1f) << 16) \
36 #define insn_ds(opcd, rts, ra, d, xo) \
37 ((((opcd) & 0x3f) << 26) \
38 | (((rts) & 0x1f) << 21) \
39 | (((ra) & 0x1f) << 16) \
43 #define insn_xfx(opcd, rts, spr, xo) \
44 ((((opcd) & 0x3f) << 26) \
45 | (((rts) & 0x1f) << 21) \
46 | (((spr) & 0x1f) << 16) \
47 | (((spr) & 0x3e0) << 6) \
48 | (((xo) & 0x3ff) << 1))
50 /* If DESC is the address of a 64-bit PowerPC FreeBSD function
51 descriptor, return the descriptor's entry point. */
54 ppc64_desc_entry_point (struct gdbarch
*gdbarch
, CORE_ADDR desc
)
56 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
57 /* The first word of the descriptor is the entry point. */
58 return (CORE_ADDR
) read_memory_unsigned_integer (desc
, 8, byte_order
);
61 /* Pattern for the standard linkage function. These are built by
62 build_plt_stub in elf64-ppc.c, whose GLINK argument is always
65 static struct ppc_insn_pattern ppc64_standard_linkage1
[] =
67 /* addis r12, r2, <any> */
68 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
71 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
73 /* ld r11, <any>(r12) */
74 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
76 /* addis r12, r12, 1 <optional> */
77 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
79 /* ld r2, <any>(r12) */
80 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
82 /* addis r12, r12, 1 <optional> */
83 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
86 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
88 /* ld r11, <any>(r12) <optional> */
89 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
92 { -1, 0x4e800420, 0 },
97 #define PPC64_STANDARD_LINKAGE1_LEN ARRAY_SIZE (ppc64_standard_linkage1)
99 static struct ppc_insn_pattern ppc64_standard_linkage2
[] =
101 /* addis r12, r2, <any> */
102 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
105 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
107 /* ld r11, <any>(r12) */
108 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
110 /* addi r12, r12, <any> <optional> */
111 { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },
114 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
116 /* ld r2, <any>(r12) */
117 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
119 /* ld r11, <any>(r12) <optional> */
120 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 },
123 { -1, 0x4e800420, 0 },
128 #define PPC64_STANDARD_LINKAGE2_LEN ARRAY_SIZE (ppc64_standard_linkage2)
130 static struct ppc_insn_pattern ppc64_standard_linkage3
[] =
133 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
135 /* ld r11, <any>(r2) */
136 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
138 /* addi r2, r2, <any> <optional> */
139 { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },
142 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
144 /* ld r11, <any>(r2) <optional> */
145 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 },
147 /* ld r2, <any>(r2) */
148 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },
151 { -1, 0x4e800420, 0 },
156 #define PPC64_STANDARD_LINKAGE3_LEN ARRAY_SIZE (ppc64_standard_linkage3)
158 /* When the dynamic linker is doing lazy symbol resolution, the first
159 call to a function in another object will go like this:
161 - The user's function calls the linkage function:
163 100007c4: 4b ff fc d5 bl 10000498
164 100007c8: e8 41 00 28 ld r2,40(r1)
166 - The linkage function loads the entry point (and other stuff) from
167 the function descriptor in the PLT, and jumps to it:
169 10000498: 3d 82 00 00 addis r12,r2,0
170 1000049c: f8 41 00 28 std r2,40(r1)
171 100004a0: e9 6c 80 98 ld r11,-32616(r12)
172 100004a4: e8 4c 80 a0 ld r2,-32608(r12)
173 100004a8: 7d 69 03 a6 mtctr r11
174 100004ac: e9 6c 80 a8 ld r11,-32600(r12)
175 100004b0: 4e 80 04 20 bctr
177 - But since this is the first time that PLT entry has been used, it
178 sends control to its glink entry. That loads the number of the
179 PLT entry and jumps to the common glink0 code:
181 10000c98: 38 00 00 00 li r0,0
182 10000c9c: 4b ff ff dc b 10000c78
184 - The common glink0 code then transfers control to the dynamic
187 10000c78: e8 41 00 28 ld r2,40(r1)
188 10000c7c: 3d 82 00 00 addis r12,r2,0
189 10000c80: e9 6c 80 80 ld r11,-32640(r12)
190 10000c84: e8 4c 80 88 ld r2,-32632(r12)
191 10000c88: 7d 69 03 a6 mtctr r11
192 10000c8c: e9 6c 80 90 ld r11,-32624(r12)
193 10000c90: 4e 80 04 20 bctr
195 Eventually, this code will figure out how to skip all of this,
196 including the dynamic linker. At the moment, we just get through
197 the linkage function. */
199 /* If the current thread is about to execute a series of instructions
200 at PC matching the ppc64_standard_linkage pattern, and INSN is the result
201 from that pattern match, return the code address to which the
202 standard linkage function will send them. (This doesn't deal with
203 dynamic linker lazy symbol resolution stubs.) */
206 ppc64_standard_linkage1_target (struct frame_info
*frame
,
207 CORE_ADDR pc
, unsigned int *insn
)
209 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
210 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
212 /* The address of the function descriptor this linkage function
215 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
216 tdep
->ppc_gp0_regnum
+ 2)
217 + (ppc_insn_d_field (insn
[0]) << 16)
218 + ppc_insn_ds_field (insn
[2]));
220 /* The first word of the descriptor is the entry point. Return that. */
221 return ppc64_desc_entry_point (gdbarch
, desc
);
225 ppc64_standard_linkage2_target (struct frame_info
*frame
,
226 CORE_ADDR pc
, unsigned int *insn
)
228 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
229 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
231 /* The address of the function descriptor this linkage function
234 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
235 tdep
->ppc_gp0_regnum
+ 2)
236 + (ppc_insn_d_field (insn
[0]) << 16)
237 + ppc_insn_ds_field (insn
[2]));
239 /* The first word of the descriptor is the entry point. Return that. */
240 return ppc64_desc_entry_point (gdbarch
, desc
);
244 ppc64_standard_linkage3_target (struct frame_info
*frame
,
245 CORE_ADDR pc
, unsigned int *insn
)
247 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
248 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
250 /* The address of the function descriptor this linkage function
253 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
254 tdep
->ppc_gp0_regnum
+ 2)
255 + ppc_insn_ds_field (insn
[1]));
257 /* The first word of the descriptor is the entry point. Return that. */
258 return ppc64_desc_entry_point (gdbarch
, desc
);
262 /* Given that we've begun executing a call trampoline at PC, return
263 the entry point of the function the trampoline will go to. */
266 ppc64_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
268 unsigned int ppc64_standard_linkage1_insn
[PPC64_STANDARD_LINKAGE1_LEN
];
269 unsigned int ppc64_standard_linkage2_insn
[PPC64_STANDARD_LINKAGE2_LEN
];
270 unsigned int ppc64_standard_linkage3_insn
[PPC64_STANDARD_LINKAGE3_LEN
];
273 if (ppc_insns_match_pattern (pc
, ppc64_standard_linkage1
,
274 ppc64_standard_linkage1_insn
))
275 pc
= ppc64_standard_linkage1_target (frame
, pc
,
276 ppc64_standard_linkage1_insn
);
277 else if (ppc_insns_match_pattern (pc
, ppc64_standard_linkage2
,
278 ppc64_standard_linkage2_insn
))
279 pc
= ppc64_standard_linkage2_target (frame
, pc
,
280 ppc64_standard_linkage2_insn
);
281 else if (ppc_insns_match_pattern (pc
, ppc64_standard_linkage3
,
282 ppc64_standard_linkage3_insn
))
283 pc
= ppc64_standard_linkage3_target (frame
, pc
,
284 ppc64_standard_linkage3_insn
);
288 /* The PLT descriptor will either point to the already resolved target
289 address, or else to a glink stub. As the latter carry synthetic @plt
290 symbols, find_solib_trampoline_target should be able to resolve them. */
291 target
= find_solib_trampoline_target (frame
, pc
);
292 return target
? target
: pc
;
295 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
298 Usually a function pointer's representation is simply the address
299 of the function. On GNU/Linux on the PowerPC however, a function
300 pointer may be a pointer to a function descriptor.
302 For PPC64, a function descriptor is a TOC entry, in a data section,
303 which contains three words: the first word is the address of the
304 function, the second word is the TOC pointer (r2), and the third word
305 is the static chain value.
307 Throughout GDB it is currently assumed that a function pointer contains
308 the address of the function, which is not easy to fix. In addition, the
309 conversion of a function address to a function pointer would
310 require allocation of a TOC entry in the inferior's memory space,
311 with all its drawbacks. To be able to call C++ virtual methods in
312 the inferior (which are called via function pointers),
313 find_function_addr uses this function to get the function address
314 from a function pointer.
316 If ADDR points at what is clearly a function descriptor, transform
317 it into the address of the corresponding function, if needed. Be
318 conservative, otherwise GDB will do the transformation on any
319 random addresses such as occur when there is no symbol table. */
322 ppc64_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
324 struct target_ops
*targ
)
326 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
327 struct target_section
*s
= target_section_by_addr (targ
, addr
);
329 /* Check if ADDR points to a function descriptor. */
330 if (s
&& strcmp (s
->the_bfd_section
->name
, ".opd") == 0)
332 /* There may be relocations that need to be applied to the .opd
333 section. Unfortunately, this function may be called at a time
334 where these relocations have not yet been performed -- this can
335 happen for example shortly after a library has been loaded with
336 dlopen, but ld.so has not yet applied the relocations.
338 To cope with both the case where the relocation has been applied,
339 and the case where it has not yet been applied, we do *not* read
340 the (maybe) relocated value from target memory, but we instead
341 read the non-relocated value from the BFD, and apply the relocation
344 This makes the assumption that all .opd entries are always relocated
345 by the same offset the section itself was relocated. This should
346 always be the case for GNU/Linux executables and shared libraries.
347 Note that other kind of object files (e.g. those added via
348 add-symbol-files) will currently never end up here anyway, as this
349 function accesses *target* sections only; only the main exec and
350 shared libraries are ever added to the target. */
355 res
= bfd_get_section_contents (s
->bfd
, s
->the_bfd_section
,
356 &buf
, addr
- s
->addr
, 8);
358 return extract_unsigned_integer (buf
, 8, byte_order
)
359 - bfd_section_vma (s
->bfd
, s
->the_bfd_section
) + s
->addr
;