Commit | Line | Data |
---|---|---|
45fe57e7 AT |
1 | /* Common target-dependent code for ppc64 GDB, the GNU debugger. |
2 | ||
ecd75fc8 | 3 | Copyright (C) 1986-2014 Free Software Foundation, Inc. |
45fe57e7 AT |
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 | ||
ef1bc9e7 AM |
51 | /* If PLT is the address of a 64-bit PowerPC PLT entry, |
52 | return the function's entry point. */ | |
45fe57e7 AT |
53 | |
54 | static CORE_ADDR | |
ef1bc9e7 | 55 | ppc64_plt_entry_point (struct gdbarch *gdbarch, CORE_ADDR plt) |
45fe57e7 AT |
56 | { |
57 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
ef1bc9e7 AM |
58 | /* The first word of the PLT entry is the function entry point. */ |
59 | return (CORE_ADDR) read_memory_unsigned_integer (plt, 8, byte_order); | |
45fe57e7 AT |
60 | } |
61 | ||
845d4708 AM |
62 | /* Patterns for the standard linkage functions. These are built by |
63 | build_plt_stub in bfd/elf64-ppc.c. */ | |
64 | ||
ef1bc9e7 | 65 | /* Old ELFv1 PLT call stub. */ |
45fe57e7 AT |
66 | |
67 | static struct ppc_insn_pattern ppc64_standard_linkage1[] = | |
68 | { | |
69 | /* addis r12, r2, <any> */ | |
70 | { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 }, | |
71 | ||
72 | /* std r2, 40(r1) */ | |
73 | { -1, insn_ds (62, 2, 1, 40, 0), 0 }, | |
74 | ||
75 | /* ld r11, <any>(r12) */ | |
76 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, | |
77 | ||
78 | /* addis r12, r12, 1 <optional> */ | |
79 | { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, | |
80 | ||
81 | /* ld r2, <any>(r12) */ | |
82 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, | |
83 | ||
84 | /* addis r12, r12, 1 <optional> */ | |
85 | { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 }, | |
86 | ||
87 | /* mtctr r11 */ | |
88 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
89 | ||
90 | /* ld r11, <any>(r12) <optional> */ | |
91 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, | |
92 | ||
93 | /* bctr */ | |
94 | { -1, 0x4e800420, 0 }, | |
95 | ||
96 | { 0, 0, 0 } | |
97 | }; | |
98 | ||
ef1bc9e7 | 99 | /* ELFv1 PLT call stub to access PLT entries more than +/- 32k from r2. |
845d4708 AM |
100 | Also supports older stub with different placement of std 2,40(1), |
101 | a stub that omits the std 2,40(1), and both versions of power7 | |
102 | thread safety read barriers. Note that there are actually two more | |
103 | instructions following "cmpldi r2, 0", "bnectr+" and "b <glink_i>", | |
104 | but there isn't any need to match them. */ | |
45fe57e7 AT |
105 | |
106 | static struct ppc_insn_pattern ppc64_standard_linkage2[] = | |
107 | { | |
845d4708 AM |
108 | /* std r2, 40(r1) <optional> */ |
109 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
110 | ||
45fe57e7 AT |
111 | /* addis r12, r2, <any> */ |
112 | { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 }, | |
113 | ||
845d4708 AM |
114 | /* std r2, 40(r1) <optional> */ |
115 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
45fe57e7 AT |
116 | |
117 | /* ld r11, <any>(r12) */ | |
118 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 }, | |
119 | ||
120 | /* addi r12, r12, <any> <optional> */ | |
121 | { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 }, | |
122 | ||
123 | /* mtctr r11 */ | |
124 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
125 | ||
845d4708 AM |
126 | /* xor r11, r11, r11 <optional> */ |
127 | { -1, 0x7d6b5a78, 1 }, | |
128 | ||
129 | /* add r12, r12, r11 <optional> */ | |
130 | { -1, 0x7d8c5a14, 1 }, | |
131 | ||
45fe57e7 AT |
132 | /* ld r2, <any>(r12) */ |
133 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 }, | |
134 | ||
135 | /* ld r11, <any>(r12) <optional> */ | |
136 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 1 }, | |
137 | ||
845d4708 AM |
138 | /* bctr <optional> */ |
139 | { -1, 0x4e800420, 1 }, | |
140 | ||
141 | /* cmpldi r2, 0 <optional> */ | |
142 | { -1, 0x28220000, 1 }, | |
45fe57e7 AT |
143 | |
144 | { 0, 0, 0 } | |
145 | }; | |
146 | ||
ef1bc9e7 | 147 | /* ELFv1 PLT call stub to access PLT entries within +/- 32k of r2. */ |
45fe57e7 AT |
148 | |
149 | static struct ppc_insn_pattern ppc64_standard_linkage3[] = | |
150 | { | |
845d4708 AM |
151 | /* std r2, 40(r1) <optional> */ |
152 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
45fe57e7 AT |
153 | |
154 | /* ld r11, <any>(r2) */ | |
155 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 }, | |
156 | ||
157 | /* addi r2, r2, <any> <optional> */ | |
158 | { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 }, | |
159 | ||
160 | /* mtctr r11 */ | |
161 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 }, | |
162 | ||
845d4708 AM |
163 | /* xor r11, r11, r11 <optional> */ |
164 | { -1, 0x7d6b5a78, 1 }, | |
165 | ||
166 | /* add r2, r2, r11 <optional> */ | |
167 | { -1, 0x7c425a14, 1 }, | |
168 | ||
45fe57e7 AT |
169 | /* ld r11, <any>(r2) <optional> */ |
170 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 }, | |
171 | ||
172 | /* ld r2, <any>(r2) */ | |
173 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 }, | |
174 | ||
845d4708 AM |
175 | /* bctr <optional> */ |
176 | { -1, 0x4e800420, 1 }, | |
177 | ||
178 | /* cmpldi r2, 0 <optional> */ | |
179 | { -1, 0x28220000, 1 }, | |
45fe57e7 AT |
180 | |
181 | { 0, 0, 0 } | |
182 | }; | |
183 | ||
ef1bc9e7 AM |
184 | /* ELFv1 PLT call stub to access PLT entries more than +/- 32k from r2. |
185 | A more modern variant of ppc64_standard_linkage2 differing in | |
186 | register usage. */ | |
187 | ||
188 | static struct ppc_insn_pattern ppc64_standard_linkage4[] = | |
189 | { | |
190 | /* std r2, 40(r1) <optional> */ | |
191 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
192 | ||
193 | /* addis r11, r2, <any> */ | |
194 | { insn_d (-1, -1, -1, 0), insn_d (15, 11, 2, 0), 0 }, | |
195 | ||
196 | /* ld r12, <any>(r11) */ | |
197 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 12, 11, 0, 0), 0 }, | |
198 | ||
199 | /* addi r11, r11, <any> <optional> */ | |
200 | { insn_d (-1, -1, -1, 0), insn_d (14, 11, 11, 0), 1 }, | |
201 | ||
202 | /* mtctr r12 */ | |
203 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 12, 9, 467), 0 }, | |
204 | ||
205 | /* xor r2, r12, r12 <optional> */ | |
206 | { -1, 0x7d826278, 1 }, | |
207 | ||
208 | /* add r11, r11, r2 <optional> */ | |
209 | { -1, 0x7d6b1214, 1 }, | |
210 | ||
211 | /* ld r2, <any>(r11) */ | |
212 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 11, 0, 0), 0 }, | |
213 | ||
214 | /* ld r11, <any>(r11) <optional> */ | |
215 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 11, 0, 0), 1 }, | |
216 | ||
217 | /* bctr <optional> */ | |
218 | { -1, 0x4e800420, 1 }, | |
219 | ||
220 | /* cmpldi r2, 0 <optional> */ | |
221 | { -1, 0x28220000, 1 }, | |
222 | ||
223 | { 0, 0, 0 } | |
224 | }; | |
225 | ||
226 | /* ELFv1 PLT call stub to access PLT entries within +/- 32k of r2. | |
227 | A more modern variant of ppc64_standard_linkage3 differing in | |
228 | register usage. */ | |
229 | ||
230 | static struct ppc_insn_pattern ppc64_standard_linkage5[] = | |
231 | { | |
232 | /* std r2, 40(r1) <optional> */ | |
233 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
234 | ||
235 | /* ld r12, <any>(r2) */ | |
236 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 12, 2, 0, 0), 0 }, | |
237 | ||
238 | /* addi r2, r2, <any> <optional> */ | |
239 | { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 }, | |
240 | ||
241 | /* mtctr r12 */ | |
242 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 12, 9, 467), 0 }, | |
243 | ||
244 | /* xor r11, r12, r12 <optional> */ | |
245 | { -1, 0x7d8b6278, 1 }, | |
246 | ||
247 | /* add r2, r2, r11 <optional> */ | |
248 | { -1, 0x7c425a14, 1 }, | |
249 | ||
250 | /* ld r11, <any>(r2) <optional> */ | |
251 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 1 }, | |
252 | ||
253 | /* ld r2, <any>(r2) */ | |
254 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 }, | |
255 | ||
256 | /* bctr <optional> */ | |
257 | { -1, 0x4e800420, 1 }, | |
258 | ||
259 | /* cmpldi r2, 0 <optional> */ | |
260 | { -1, 0x28220000, 1 }, | |
261 | ||
262 | { 0, 0, 0 } | |
263 | }; | |
264 | ||
265 | /* ELFv2 PLT call stub to access PLT entries more than +/- 32k from r2. */ | |
266 | ||
267 | static struct ppc_insn_pattern ppc64_standard_linkage6[] = | |
268 | { | |
269 | /* std r2, 24(r1) <optional> */ | |
270 | { -1, insn_ds (62, 2, 1, 24, 0), 1 }, | |
271 | ||
272 | /* addis r11, r2, <any> */ | |
273 | { insn_d (-1, -1, -1, 0), insn_d (15, 11, 2, 0), 0 }, | |
274 | ||
275 | /* ld r12, <any>(r11) */ | |
276 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 12, 11, 0, 0), 0 }, | |
277 | ||
278 | /* mtctr r12 */ | |
279 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 12, 9, 467), 0 }, | |
280 | ||
281 | /* bctr */ | |
282 | { -1, 0x4e800420, 0 }, | |
283 | ||
284 | { 0, 0, 0 } | |
285 | }; | |
286 | ||
287 | /* ELFv2 PLT call stub to access PLT entries within +/- 32k of r2. */ | |
288 | ||
289 | static struct ppc_insn_pattern ppc64_standard_linkage7[] = | |
290 | { | |
291 | /* std r2, 24(r1) <optional> */ | |
292 | { -1, insn_ds (62, 2, 1, 40, 0), 1 }, | |
293 | ||
294 | /* ld r12, <any>(r2) */ | |
295 | { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 12, 2, 0, 0), 0 }, | |
296 | ||
297 | /* mtctr r12 */ | |
298 | { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 12, 9, 467), 0 }, | |
299 | ||
300 | /* bctr */ | |
301 | { -1, 0x4e800420, 0 }, | |
302 | ||
303 | { 0, 0, 0 } | |
304 | }; | |
305 | ||
45fe57e7 AT |
306 | /* When the dynamic linker is doing lazy symbol resolution, the first |
307 | call to a function in another object will go like this: | |
308 | ||
309 | - The user's function calls the linkage function: | |
310 | ||
845d4708 AM |
311 | 100003d4: 4b ff ff ad bl 10000380 <nnnn.plt_call.printf> |
312 | 100003d8: e8 41 00 28 ld r2,40(r1) | |
45fe57e7 | 313 | |
845d4708 AM |
314 | - The linkage function loads the entry point and toc pointer from |
315 | the function descriptor in the PLT, and jumps to it: | |
45fe57e7 | 316 | |
845d4708 AM |
317 | <nnnn.plt_call.printf>: |
318 | 10000380: f8 41 00 28 std r2,40(r1) | |
319 | 10000384: e9 62 80 78 ld r11,-32648(r2) | |
320 | 10000388: 7d 69 03 a6 mtctr r11 | |
321 | 1000038c: e8 42 80 80 ld r2,-32640(r2) | |
322 | 10000390: 28 22 00 00 cmpldi r2,0 | |
323 | 10000394: 4c e2 04 20 bnectr+ | |
324 | 10000398: 48 00 03 a0 b 10000738 <printf@plt> | |
45fe57e7 AT |
325 | |
326 | - But since this is the first time that PLT entry has been used, it | |
845d4708 AM |
327 | sends control to its glink entry. That loads the number of the |
328 | PLT entry and jumps to the common glink0 code: | |
45fe57e7 | 329 | |
845d4708 AM |
330 | <printf@plt>: |
331 | 10000738: 38 00 00 01 li r0,1 | |
332 | 1000073c: 4b ff ff bc b 100006f8 <__glink_PLTresolve> | |
45fe57e7 AT |
333 | |
334 | - The common glink0 code then transfers control to the dynamic | |
845d4708 AM |
335 | linker's fixup code: |
336 | ||
337 | 100006f0: 0000000000010440 .quad plt0 - (. + 16) | |
338 | <__glink_PLTresolve>: | |
339 | 100006f8: 7d 88 02 a6 mflr r12 | |
340 | 100006fc: 42 9f 00 05 bcl 20,4*cr7+so,10000700 | |
341 | 10000700: 7d 68 02 a6 mflr r11 | |
342 | 10000704: e8 4b ff f0 ld r2,-16(r11) | |
343 | 10000708: 7d 88 03 a6 mtlr r12 | |
344 | 1000070c: 7d 82 5a 14 add r12,r2,r11 | |
345 | 10000710: e9 6c 00 00 ld r11,0(r12) | |
346 | 10000714: e8 4c 00 08 ld r2,8(r12) | |
347 | 10000718: 7d 69 03 a6 mtctr r11 | |
348 | 1000071c: e9 6c 00 10 ld r11,16(r12) | |
349 | 10000720: 4e 80 04 20 bctr | |
45fe57e7 AT |
350 | |
351 | Eventually, this code will figure out how to skip all of this, | |
352 | including the dynamic linker. At the moment, we just get through | |
353 | the linkage function. */ | |
354 | ||
355 | /* If the current thread is about to execute a series of instructions | |
356 | at PC matching the ppc64_standard_linkage pattern, and INSN is the result | |
357 | from that pattern match, return the code address to which the | |
358 | standard linkage function will send them. (This doesn't deal with | |
359 | dynamic linker lazy symbol resolution stubs.) */ | |
360 | ||
361 | static CORE_ADDR | |
362 | ppc64_standard_linkage1_target (struct frame_info *frame, | |
363 | CORE_ADDR pc, unsigned int *insn) | |
364 | { | |
365 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
366 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
367 | ||
ef1bc9e7 AM |
368 | /* The address of the PLT entry this linkage function references. */ |
369 | CORE_ADDR plt | |
45fe57e7 AT |
370 | = ((CORE_ADDR) get_frame_register_unsigned (frame, |
371 | tdep->ppc_gp0_regnum + 2) | |
372 | + (ppc_insn_d_field (insn[0]) << 16) | |
373 | + ppc_insn_ds_field (insn[2])); | |
374 | ||
ef1bc9e7 | 375 | return ppc64_plt_entry_point (gdbarch, plt); |
45fe57e7 AT |
376 | } |
377 | ||
378 | static CORE_ADDR | |
379 | ppc64_standard_linkage2_target (struct frame_info *frame, | |
380 | CORE_ADDR pc, unsigned int *insn) | |
381 | { | |
382 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
383 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
384 | ||
ef1bc9e7 AM |
385 | /* The address of the PLT entry this linkage function references. */ |
386 | CORE_ADDR plt | |
45fe57e7 AT |
387 | = ((CORE_ADDR) get_frame_register_unsigned (frame, |
388 | tdep->ppc_gp0_regnum + 2) | |
845d4708 AM |
389 | + (ppc_insn_d_field (insn[1]) << 16) |
390 | + ppc_insn_ds_field (insn[3])); | |
45fe57e7 | 391 | |
ef1bc9e7 | 392 | return ppc64_plt_entry_point (gdbarch, plt); |
45fe57e7 AT |
393 | } |
394 | ||
395 | static CORE_ADDR | |
396 | ppc64_standard_linkage3_target (struct frame_info *frame, | |
397 | CORE_ADDR pc, unsigned int *insn) | |
398 | { | |
399 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
400 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
401 | ||
ef1bc9e7 AM |
402 | /* The address of the PLT entry this linkage function references. */ |
403 | CORE_ADDR plt | |
45fe57e7 AT |
404 | = ((CORE_ADDR) get_frame_register_unsigned (frame, |
405 | tdep->ppc_gp0_regnum + 2) | |
406 | + ppc_insn_ds_field (insn[1])); | |
407 | ||
ef1bc9e7 AM |
408 | return ppc64_plt_entry_point (gdbarch, plt); |
409 | } | |
410 | ||
411 | static CORE_ADDR | |
412 | ppc64_standard_linkage4_target (struct frame_info *frame, | |
413 | CORE_ADDR pc, unsigned int *insn) | |
414 | { | |
415 | struct gdbarch *gdbarch = get_frame_arch (frame); | |
416 | struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | |
417 | ||
418 | CORE_ADDR plt | |
419 | = ((CORE_ADDR) get_frame_register_unsigned (frame, tdep->ppc_gp0_regnum + 2) | |
420 | + (ppc_insn_d_field (insn[1]) << 16) | |
421 | + ppc_insn_ds_field (insn[2])); | |
422 | ||
423 | return ppc64_plt_entry_point (gdbarch, plt); | |
45fe57e7 AT |
424 | } |
425 | ||
426 | ||
427 | /* Given that we've begun executing a call trampoline at PC, return | |
428 | the entry point of the function the trampoline will go to. */ | |
429 | ||
430 | CORE_ADDR | |
431 | ppc64_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc) | |
432 | { | |
845d4708 | 433 | #define MAX(a,b) ((a) > (b) ? (a) : (b)) |
ef1bc9e7 AM |
434 | unsigned int insns[MAX (MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage1), |
435 | ARRAY_SIZE (ppc64_standard_linkage2)), | |
436 | MAX (ARRAY_SIZE (ppc64_standard_linkage3), | |
437 | ARRAY_SIZE (ppc64_standard_linkage4))), | |
438 | MAX (MAX (ARRAY_SIZE (ppc64_standard_linkage5), | |
439 | ARRAY_SIZE (ppc64_standard_linkage6)), | |
440 | ARRAY_SIZE (ppc64_standard_linkage7))) - 1]; | |
45fe57e7 AT |
441 | CORE_ADDR target; |
442 | ||
ef1bc9e7 AM |
443 | if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage7, insns)) |
444 | pc = ppc64_standard_linkage3_target (frame, pc, insns); | |
445 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage6, insns)) | |
446 | pc = ppc64_standard_linkage4_target (frame, pc, insns); | |
447 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage5, insns) | |
448 | && (insns[8] != 0 || insns[9] != 0)) | |
449 | pc = ppc64_standard_linkage3_target (frame, pc, insns); | |
450 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage4, insns) | |
451 | && (insns[9] != 0 || insns[10] != 0)) | |
452 | pc = ppc64_standard_linkage4_target (frame, pc, insns); | |
453 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage3, insns) | |
454 | && (insns[8] != 0 || insns[9] != 0)) | |
845d4708 AM |
455 | pc = ppc64_standard_linkage3_target (frame, pc, insns); |
456 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage2, insns) | |
457 | && (insns[10] != 0 || insns[11] != 0)) | |
458 | pc = ppc64_standard_linkage2_target (frame, pc, insns); | |
459 | else if (ppc_insns_match_pattern (frame, pc, ppc64_standard_linkage1, insns)) | |
460 | pc = ppc64_standard_linkage1_target (frame, pc, insns); | |
45fe57e7 AT |
461 | else |
462 | return 0; | |
463 | ||
464 | /* The PLT descriptor will either point to the already resolved target | |
465 | address, or else to a glink stub. As the latter carry synthetic @plt | |
466 | symbols, find_solib_trampoline_target should be able to resolve them. */ | |
467 | target = find_solib_trampoline_target (frame, pc); | |
468 | return target ? target : pc; | |
469 | } | |
470 | ||
471 | /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64 | |
472 | GNU/Linux. | |
473 | ||
474 | Usually a function pointer's representation is simply the address | |
475 | of the function. On GNU/Linux on the PowerPC however, a function | |
476 | pointer may be a pointer to a function descriptor. | |
477 | ||
478 | For PPC64, a function descriptor is a TOC entry, in a data section, | |
479 | which contains three words: the first word is the address of the | |
480 | function, the second word is the TOC pointer (r2), and the third word | |
481 | is the static chain value. | |
482 | ||
483 | Throughout GDB it is currently assumed that a function pointer contains | |
484 | the address of the function, which is not easy to fix. In addition, the | |
485 | conversion of a function address to a function pointer would | |
486 | require allocation of a TOC entry in the inferior's memory space, | |
487 | with all its drawbacks. To be able to call C++ virtual methods in | |
488 | the inferior (which are called via function pointers), | |
489 | find_function_addr uses this function to get the function address | |
490 | from a function pointer. | |
491 | ||
492 | If ADDR points at what is clearly a function descriptor, transform | |
493 | it into the address of the corresponding function, if needed. Be | |
494 | conservative, otherwise GDB will do the transformation on any | |
495 | random addresses such as occur when there is no symbol table. */ | |
496 | ||
497 | CORE_ADDR | |
498 | ppc64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, | |
499 | CORE_ADDR addr, | |
500 | struct target_ops *targ) | |
501 | { | |
502 | enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); | |
503 | struct target_section *s = target_section_by_addr (targ, addr); | |
504 | ||
505 | /* Check if ADDR points to a function descriptor. */ | |
506 | if (s && strcmp (s->the_bfd_section->name, ".opd") == 0) | |
507 | { | |
508 | /* There may be relocations that need to be applied to the .opd | |
509 | section. Unfortunately, this function may be called at a time | |
510 | where these relocations have not yet been performed -- this can | |
511 | happen for example shortly after a library has been loaded with | |
512 | dlopen, but ld.so has not yet applied the relocations. | |
513 | ||
514 | To cope with both the case where the relocation has been applied, | |
515 | and the case where it has not yet been applied, we do *not* read | |
516 | the (maybe) relocated value from target memory, but we instead | |
517 | read the non-relocated value from the BFD, and apply the relocation | |
518 | offset manually. | |
519 | ||
520 | This makes the assumption that all .opd entries are always relocated | |
521 | by the same offset the section itself was relocated. This should | |
522 | always be the case for GNU/Linux executables and shared libraries. | |
523 | Note that other kind of object files (e.g. those added via | |
524 | add-symbol-files) will currently never end up here anyway, as this | |
525 | function accesses *target* sections only; only the main exec and | |
526 | shared libraries are ever added to the target. */ | |
527 | ||
528 | gdb_byte buf[8]; | |
529 | int res; | |
530 | ||
57e6060e DE |
531 | res = bfd_get_section_contents (s->the_bfd_section->owner, |
532 | s->the_bfd_section, | |
45fe57e7 AT |
533 | &buf, addr - s->addr, 8); |
534 | if (res != 0) | |
535 | return extract_unsigned_integer (buf, 8, byte_order) | |
536 | - bfd_section_vma (s->bfd, s->the_bfd_section) + s->addr; | |
537 | } | |
538 | ||
539 | return addr; | |
540 | } | |
24c274a1 AM |
541 | |
542 | /* A synthetic 'dot' symbols on ppc64 has the udata.p entry pointing | |
543 | back to the original ELF symbol it was derived from. Get the size | |
544 | from that symbol. */ | |
545 | ||
546 | void | |
547 | ppc64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym) | |
548 | { | |
549 | if ((sym->flags & BSF_SYNTHETIC) != 0 && sym->udata.p != NULL) | |
550 | { | |
551 | elf_symbol_type *elf_sym = (elf_symbol_type *) sym->udata.p; | |
552 | SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size); | |
553 | } | |
554 | } |