1 /* Target-dependent code for GDB, the GNU debugger.
3 Copyright (C) 1986-1987, 1989, 1991-1997, 2000-2012 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
34 #include "solib-svr4.h"
35 #include "solib-spu.h"
39 #include "ppc-linux-tdep.h"
40 #include "trad-frame.h"
41 #include "frame-unwind.h"
42 #include "tramp-frame.h"
45 #include "elf/common.h"
46 #include "exceptions.h"
47 #include "arch-utils.h"
49 #include "xml-syscall.h"
50 #include "linux-tdep.h"
52 #include "features/rs6000/powerpc-32l.c"
53 #include "features/rs6000/powerpc-altivec32l.c"
54 #include "features/rs6000/powerpc-cell32l.c"
55 #include "features/rs6000/powerpc-vsx32l.c"
56 #include "features/rs6000/powerpc-isa205-32l.c"
57 #include "features/rs6000/powerpc-isa205-altivec32l.c"
58 #include "features/rs6000/powerpc-isa205-vsx32l.c"
59 #include "features/rs6000/powerpc-64l.c"
60 #include "features/rs6000/powerpc-altivec64l.c"
61 #include "features/rs6000/powerpc-cell64l.c"
62 #include "features/rs6000/powerpc-vsx64l.c"
63 #include "features/rs6000/powerpc-isa205-64l.c"
64 #include "features/rs6000/powerpc-isa205-altivec64l.c"
65 #include "features/rs6000/powerpc-isa205-vsx64l.c"
66 #include "features/rs6000/powerpc-e500l.c"
68 /* The syscall's XML filename for PPC and PPC64. */
69 #define XML_SYSCALL_FILENAME_PPC "syscalls/ppc-linux.xml"
70 #define XML_SYSCALL_FILENAME_PPC64 "syscalls/ppc64-linux.xml"
72 /* ppc_linux_memory_remove_breakpoints attempts to remove a breakpoint
73 in much the same fashion as memory_remove_breakpoint in mem-break.c,
74 but is careful not to write back the previous contents if the code
75 in question has changed in between inserting the breakpoint and
78 Here is the problem that we're trying to solve...
80 Once upon a time, before introducing this function to remove
81 breakpoints from the inferior, setting a breakpoint on a shared
82 library function prior to running the program would not work
83 properly. In order to understand the problem, it is first
84 necessary to understand a little bit about dynamic linking on
87 A call to a shared library function is accomplished via a bl
88 (branch-and-link) instruction whose branch target is an entry
89 in the procedure linkage table (PLT). The PLT in the object
90 file is uninitialized. To gdb, prior to running the program, the
91 entries in the PLT are all zeros.
93 Once the program starts running, the shared libraries are loaded
94 and the procedure linkage table is initialized, but the entries in
95 the table are not (necessarily) resolved. Once a function is
96 actually called, the code in the PLT is hit and the function is
97 resolved. In order to better illustrate this, an example is in
98 order; the following example is from the gdb testsuite.
100 We start the program shmain.
102 [kev@arroyo testsuite]$ ../gdb gdb.base/shmain
105 We place two breakpoints, one on shr1 and the other on main.
108 Breakpoint 1 at 0x100409d4
110 Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
112 Examine the instruction (and the immediatly following instruction)
113 upon which the breakpoint was placed. Note that the PLT entry
114 for shr1 contains zeros.
116 (gdb) x/2i 0x100409d4
117 0x100409d4 <shr1>: .long 0x0
118 0x100409d8 <shr1+4>: .long 0x0
123 Starting program: gdb.base/shmain
124 Breakpoint 1 at 0xffaf790: file gdb.base/shr1.c, line 19.
126 Breakpoint 2, main ()
127 at gdb.base/shmain.c:44
130 Examine the PLT again. Note that the loading of the shared
131 library has initialized the PLT to code which loads a constant
132 (which I think is an index into the GOT) into r11 and then
133 branchs a short distance to the code which actually does the
136 (gdb) x/2i 0x100409d4
137 0x100409d4 <shr1>: li r11,4
138 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
142 Breakpoint 1, shr1 (x=1)
143 at gdb.base/shr1.c:19
146 Now we've hit the breakpoint at shr1. (The breakpoint was
147 reset from the PLT entry to the actual shr1 function after the
148 shared library was loaded.) Note that the PLT entry has been
149 resolved to contain a branch that takes us directly to shr1.
150 (The real one, not the PLT entry.)
152 (gdb) x/2i 0x100409d4
153 0x100409d4 <shr1>: b 0xffaf76c <shr1>
154 0x100409d8 <shr1+4>: b 0x10040984 <sg+4>
156 The thing to note here is that the PLT entry for shr1 has been
159 Now the problem should be obvious. GDB places a breakpoint (a
160 trap instruction) on the zero value of the PLT entry for shr1.
161 Later on, after the shared library had been loaded and the PLT
162 initialized, GDB gets a signal indicating this fact and attempts
163 (as it always does when it stops) to remove all the breakpoints.
165 The breakpoint removal was causing the former contents (a zero
166 word) to be written back to the now initialized PLT entry thus
167 destroying a portion of the initialization that had occurred only a
168 short time ago. When execution continued, the zero word would be
169 executed as an instruction an illegal instruction trap was
170 generated instead. (0 is not a legal instruction.)
172 The fix for this problem was fairly straightforward. The function
173 memory_remove_breakpoint from mem-break.c was copied to this file,
174 modified slightly, and renamed to ppc_linux_memory_remove_breakpoint.
175 In tm-linux.h, MEMORY_REMOVE_BREAKPOINT is defined to call this new
178 The differences between ppc_linux_memory_remove_breakpoint () and
179 memory_remove_breakpoint () are minor. All that the former does
180 that the latter does not is check to make sure that the breakpoint
181 location actually contains a breakpoint (trap instruction) prior
182 to attempting to write back the old contents. If it does contain
183 a trap instruction, we allow the old contents to be written back.
184 Otherwise, we silently do nothing.
186 The big question is whether memory_remove_breakpoint () should be
187 changed to have the same functionality. The downside is that more
188 traffic is generated for remote targets since we'll have an extra
189 fetch of a memory word each time a breakpoint is removed.
191 For the time being, we'll leave this self-modifying-code-friendly
192 version in ppc-linux-tdep.c, but it ought to be migrated somewhere
193 else in the event that some other platform has similar needs with
194 regard to removing breakpoints in some potentially self modifying
197 ppc_linux_memory_remove_breakpoint (struct gdbarch
*gdbarch
,
198 struct bp_target_info
*bp_tgt
)
200 CORE_ADDR addr
= bp_tgt
->placed_address
;
201 const unsigned char *bp
;
204 gdb_byte old_contents
[BREAKPOINT_MAX
];
205 struct cleanup
*cleanup
;
207 /* Determine appropriate breakpoint contents and size for this address. */
208 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &bplen
);
210 error (_("Software breakpoints not implemented for this target."));
212 /* Make sure we see the memory breakpoints. */
213 cleanup
= make_show_memory_breakpoints_cleanup (1);
214 val
= target_read_memory (addr
, old_contents
, bplen
);
216 /* If our breakpoint is no longer at the address, this means that the
217 program modified the code on us, so it is wrong to put back the
219 if (val
== 0 && memcmp (bp
, old_contents
, bplen
) == 0)
220 val
= target_write_raw_memory (addr
, bp_tgt
->shadow_contents
, bplen
);
222 do_cleanups (cleanup
);
226 /* For historic reasons, PPC 32 GNU/Linux follows PowerOpen rather
227 than the 32 bit SYSV R4 ABI structure return convention - all
228 structures, no matter their size, are put in memory. Vectors,
229 which were added later, do get returned in a register though. */
231 static enum return_value_convention
232 ppc_linux_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
233 struct type
*valtype
, struct regcache
*regcache
,
234 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
236 if ((TYPE_CODE (valtype
) == TYPE_CODE_STRUCT
237 || TYPE_CODE (valtype
) == TYPE_CODE_UNION
)
238 && !((TYPE_LENGTH (valtype
) == 16 || TYPE_LENGTH (valtype
) == 8)
239 && TYPE_VECTOR (valtype
)))
240 return RETURN_VALUE_STRUCT_CONVENTION
;
242 return ppc_sysv_abi_return_value (gdbarch
, func_type
, valtype
, regcache
,
246 /* Macros for matching instructions. Note that, since all the
247 operands are masked off before they're or-ed into the instruction,
248 you can use -1 to make masks. */
250 #define insn_d(opcd, rts, ra, d) \
251 ((((opcd) & 0x3f) << 26) \
252 | (((rts) & 0x1f) << 21) \
253 | (((ra) & 0x1f) << 16) \
256 #define insn_ds(opcd, rts, ra, d, xo) \
257 ((((opcd) & 0x3f) << 26) \
258 | (((rts) & 0x1f) << 21) \
259 | (((ra) & 0x1f) << 16) \
263 #define insn_xfx(opcd, rts, spr, xo) \
264 ((((opcd) & 0x3f) << 26) \
265 | (((rts) & 0x1f) << 21) \
266 | (((spr) & 0x1f) << 16) \
267 | (((spr) & 0x3e0) << 6) \
268 | (((xo) & 0x3ff) << 1))
270 /* Read a PPC instruction from memory. PPC instructions are always
271 big-endian, no matter what endianness the program is running in, so
272 we can't use read_memory_integer or one of its friends here. */
274 read_insn (CORE_ADDR pc
)
276 unsigned char buf
[4];
278 read_memory (pc
, buf
, 4);
279 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
283 /* An instruction to match. */
286 unsigned int mask
; /* mask the insn with this... */
287 unsigned int data
; /* ...and see if it matches this. */
288 int optional
; /* If non-zero, this insn may be absent. */
291 /* Return non-zero if the instructions at PC match the series
292 described in PATTERN, or zero otherwise. PATTERN is an array of
293 'struct insn_pattern' objects, terminated by an entry whose mask is
296 When the match is successful, fill INSN[i] with what PATTERN[i]
297 matched. If PATTERN[i] is optional, and the instruction wasn't
298 present, set INSN[i] to 0 (which is not a valid PPC instruction).
299 INSN should have as many elements as PATTERN. Note that, if
300 PATTERN contains optional instructions which aren't present in
301 memory, then INSN will have holes, so INSN[i] isn't necessarily the
302 i'th instruction in memory. */
304 insns_match_pattern (CORE_ADDR pc
,
305 struct insn_pattern
*pattern
,
310 for (i
= 0; pattern
[i
].mask
; i
++)
312 insn
[i
] = read_insn (pc
);
313 if ((insn
[i
] & pattern
[i
].mask
) == pattern
[i
].data
)
315 else if (pattern
[i
].optional
)
325 /* Return the 'd' field of the d-form instruction INSN, properly
328 insn_d_field (unsigned int insn
)
330 return ((((CORE_ADDR
) insn
& 0xffff) ^ 0x8000) - 0x8000);
334 /* Return the 'ds' field of the ds-form instruction INSN, with the two
335 zero bits concatenated at the right, and properly
338 insn_ds_field (unsigned int insn
)
340 return ((((CORE_ADDR
) insn
& 0xfffc) ^ 0x8000) - 0x8000);
344 /* If DESC is the address of a 64-bit PowerPC GNU/Linux function
345 descriptor, return the descriptor's entry point. */
347 ppc64_desc_entry_point (struct gdbarch
*gdbarch
, CORE_ADDR desc
)
349 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
350 /* The first word of the descriptor is the entry point. */
351 return (CORE_ADDR
) read_memory_unsigned_integer (desc
, 8, byte_order
);
355 /* Pattern for the standard linkage function. These are built by
356 build_plt_stub in elf64-ppc.c, whose GLINK argument is always
358 static struct insn_pattern ppc64_standard_linkage1
[] =
360 /* addis r12, r2, <any> */
361 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
364 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
366 /* ld r11, <any>(r12) */
367 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
369 /* addis r12, r12, 1 <optional> */
370 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
372 /* ld r2, <any>(r12) */
373 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
375 /* addis r12, r12, 1 <optional> */
376 { insn_d (-1, -1, -1, -1), insn_d (15, 12, 12, 1), 1 },
379 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
381 /* ld r11, <any>(r12) */
382 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
385 { -1, 0x4e800420, 0 },
389 #define PPC64_STANDARD_LINKAGE1_LEN \
390 (sizeof (ppc64_standard_linkage1) / sizeof (ppc64_standard_linkage1[0]))
392 static struct insn_pattern ppc64_standard_linkage2
[] =
394 /* addis r12, r2, <any> */
395 { insn_d (-1, -1, -1, 0), insn_d (15, 12, 2, 0), 0 },
398 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
400 /* ld r11, <any>(r12) */
401 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
403 /* addi r12, r12, <any> <optional> */
404 { insn_d (-1, -1, -1, 0), insn_d (14, 12, 12, 0), 1 },
407 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
409 /* ld r2, <any>(r12) */
410 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 12, 0, 0), 0 },
412 /* ld r11, <any>(r12) */
413 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 12, 0, 0), 0 },
416 { -1, 0x4e800420, 0 },
420 #define PPC64_STANDARD_LINKAGE2_LEN \
421 (sizeof (ppc64_standard_linkage2) / sizeof (ppc64_standard_linkage2[0]))
423 static struct insn_pattern ppc64_standard_linkage3
[] =
426 { -1, insn_ds (62, 2, 1, 40, 0), 0 },
428 /* ld r11, <any>(r2) */
429 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
431 /* addi r2, r2, <any> <optional> */
432 { insn_d (-1, -1, -1, 0), insn_d (14, 2, 2, 0), 1 },
435 { insn_xfx (-1, -1, -1, -1), insn_xfx (31, 11, 9, 467), 0 },
437 /* ld r11, <any>(r2) */
438 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 11, 2, 0, 0), 0 },
440 /* ld r2, <any>(r2) */
441 { insn_ds (-1, -1, -1, 0, -1), insn_ds (58, 2, 2, 0, 0), 0 },
444 { -1, 0x4e800420, 0 },
448 #define PPC64_STANDARD_LINKAGE3_LEN \
449 (sizeof (ppc64_standard_linkage3) / sizeof (ppc64_standard_linkage3[0]))
452 /* When the dynamic linker is doing lazy symbol resolution, the first
453 call to a function in another object will go like this:
455 - The user's function calls the linkage function:
457 100007c4: 4b ff fc d5 bl 10000498
458 100007c8: e8 41 00 28 ld r2,40(r1)
460 - The linkage function loads the entry point (and other stuff) from
461 the function descriptor in the PLT, and jumps to it:
463 10000498: 3d 82 00 00 addis r12,r2,0
464 1000049c: f8 41 00 28 std r2,40(r1)
465 100004a0: e9 6c 80 98 ld r11,-32616(r12)
466 100004a4: e8 4c 80 a0 ld r2,-32608(r12)
467 100004a8: 7d 69 03 a6 mtctr r11
468 100004ac: e9 6c 80 a8 ld r11,-32600(r12)
469 100004b0: 4e 80 04 20 bctr
471 - But since this is the first time that PLT entry has been used, it
472 sends control to its glink entry. That loads the number of the
473 PLT entry and jumps to the common glink0 code:
475 10000c98: 38 00 00 00 li r0,0
476 10000c9c: 4b ff ff dc b 10000c78
478 - The common glink0 code then transfers control to the dynamic
481 10000c78: e8 41 00 28 ld r2,40(r1)
482 10000c7c: 3d 82 00 00 addis r12,r2,0
483 10000c80: e9 6c 80 80 ld r11,-32640(r12)
484 10000c84: e8 4c 80 88 ld r2,-32632(r12)
485 10000c88: 7d 69 03 a6 mtctr r11
486 10000c8c: e9 6c 80 90 ld r11,-32624(r12)
487 10000c90: 4e 80 04 20 bctr
489 Eventually, this code will figure out how to skip all of this,
490 including the dynamic linker. At the moment, we just get through
491 the linkage function. */
493 /* If the current thread is about to execute a series of instructions
494 at PC matching the ppc64_standard_linkage pattern, and INSN is the result
495 from that pattern match, return the code address to which the
496 standard linkage function will send them. (This doesn't deal with
497 dynamic linker lazy symbol resolution stubs.) */
499 ppc64_standard_linkage1_target (struct frame_info
*frame
,
500 CORE_ADDR pc
, unsigned int *insn
)
502 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
503 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
505 /* The address of the function descriptor this linkage function
508 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
509 tdep
->ppc_gp0_regnum
+ 2)
510 + (insn_d_field (insn
[0]) << 16)
511 + insn_ds_field (insn
[2]));
513 /* The first word of the descriptor is the entry point. Return that. */
514 return ppc64_desc_entry_point (gdbarch
, desc
);
517 static struct core_regset_section ppc_linux_vsx_regset_sections
[] =
519 { ".reg", 48 * 4, "general-purpose" },
520 { ".reg2", 264, "floating-point" },
521 { ".reg-ppc-vmx", 544, "ppc Altivec" },
522 { ".reg-ppc-vsx", 256, "POWER7 VSX" },
526 static struct core_regset_section ppc_linux_vmx_regset_sections
[] =
528 { ".reg", 48 * 4, "general-purpose" },
529 { ".reg2", 264, "floating-point" },
530 { ".reg-ppc-vmx", 544, "ppc Altivec" },
534 static struct core_regset_section ppc_linux_fp_regset_sections
[] =
536 { ".reg", 48 * 4, "general-purpose" },
537 { ".reg2", 264, "floating-point" },
541 static struct core_regset_section ppc64_linux_vsx_regset_sections
[] =
543 { ".reg", 48 * 8, "general-purpose" },
544 { ".reg2", 264, "floating-point" },
545 { ".reg-ppc-vmx", 544, "ppc Altivec" },
546 { ".reg-ppc-vsx", 256, "POWER7 VSX" },
550 static struct core_regset_section ppc64_linux_vmx_regset_sections
[] =
552 { ".reg", 48 * 8, "general-purpose" },
553 { ".reg2", 264, "floating-point" },
554 { ".reg-ppc-vmx", 544, "ppc Altivec" },
558 static struct core_regset_section ppc64_linux_fp_regset_sections
[] =
560 { ".reg", 48 * 8, "general-purpose" },
561 { ".reg2", 264, "floating-point" },
566 ppc64_standard_linkage2_target (struct frame_info
*frame
,
567 CORE_ADDR pc
, unsigned int *insn
)
569 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
570 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
572 /* The address of the function descriptor this linkage function
575 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
576 tdep
->ppc_gp0_regnum
+ 2)
577 + (insn_d_field (insn
[0]) << 16)
578 + insn_ds_field (insn
[2]));
580 /* The first word of the descriptor is the entry point. Return that. */
581 return ppc64_desc_entry_point (gdbarch
, desc
);
585 ppc64_standard_linkage3_target (struct frame_info
*frame
,
586 CORE_ADDR pc
, unsigned int *insn
)
588 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
589 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
591 /* The address of the function descriptor this linkage function
594 = ((CORE_ADDR
) get_frame_register_unsigned (frame
,
595 tdep
->ppc_gp0_regnum
+ 2)
596 + insn_ds_field (insn
[1]));
598 /* The first word of the descriptor is the entry point. Return that. */
599 return ppc64_desc_entry_point (gdbarch
, desc
);
603 /* Given that we've begun executing a call trampoline at PC, return
604 the entry point of the function the trampoline will go to. */
606 ppc64_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
608 unsigned int ppc64_standard_linkage1_insn
[PPC64_STANDARD_LINKAGE1_LEN
];
609 unsigned int ppc64_standard_linkage2_insn
[PPC64_STANDARD_LINKAGE2_LEN
];
610 unsigned int ppc64_standard_linkage3_insn
[PPC64_STANDARD_LINKAGE3_LEN
];
613 if (insns_match_pattern (pc
, ppc64_standard_linkage1
,
614 ppc64_standard_linkage1_insn
))
615 pc
= ppc64_standard_linkage1_target (frame
, pc
,
616 ppc64_standard_linkage1_insn
);
617 else if (insns_match_pattern (pc
, ppc64_standard_linkage2
,
618 ppc64_standard_linkage2_insn
))
619 pc
= ppc64_standard_linkage2_target (frame
, pc
,
620 ppc64_standard_linkage2_insn
);
621 else if (insns_match_pattern (pc
, ppc64_standard_linkage3
,
622 ppc64_standard_linkage3_insn
))
623 pc
= ppc64_standard_linkage3_target (frame
, pc
,
624 ppc64_standard_linkage3_insn
);
628 /* The PLT descriptor will either point to the already resolved target
629 address, or else to a glink stub. As the latter carry synthetic @plt
630 symbols, find_solib_trampoline_target should be able to resolve them. */
631 target
= find_solib_trampoline_target (frame
, pc
);
632 return target
? target
: pc
;
636 /* Support for convert_from_func_ptr_addr (ARCH, ADDR, TARG) on PPC64
639 Usually a function pointer's representation is simply the address
640 of the function. On GNU/Linux on the PowerPC however, a function
641 pointer may be a pointer to a function descriptor.
643 For PPC64, a function descriptor is a TOC entry, in a data section,
644 which contains three words: the first word is the address of the
645 function, the second word is the TOC pointer (r2), and the third word
646 is the static chain value.
648 Throughout GDB it is currently assumed that a function pointer contains
649 the address of the function, which is not easy to fix. In addition, the
650 conversion of a function address to a function pointer would
651 require allocation of a TOC entry in the inferior's memory space,
652 with all its drawbacks. To be able to call C++ virtual methods in
653 the inferior (which are called via function pointers),
654 find_function_addr uses this function to get the function address
655 from a function pointer.
657 If ADDR points at what is clearly a function descriptor, transform
658 it into the address of the corresponding function, if needed. Be
659 conservative, otherwise GDB will do the transformation on any
660 random addresses such as occur when there is no symbol table. */
663 ppc64_linux_convert_from_func_ptr_addr (struct gdbarch
*gdbarch
,
665 struct target_ops
*targ
)
667 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
668 struct target_section
*s
= target_section_by_addr (targ
, addr
);
670 /* Check if ADDR points to a function descriptor. */
671 if (s
&& strcmp (s
->the_bfd_section
->name
, ".opd") == 0)
673 /* There may be relocations that need to be applied to the .opd
674 section. Unfortunately, this function may be called at a time
675 where these relocations have not yet been performed -- this can
676 happen for example shortly after a library has been loaded with
677 dlopen, but ld.so has not yet applied the relocations.
679 To cope with both the case where the relocation has been applied,
680 and the case where it has not yet been applied, we do *not* read
681 the (maybe) relocated value from target memory, but we instead
682 read the non-relocated value from the BFD, and apply the relocation
685 This makes the assumption that all .opd entries are always relocated
686 by the same offset the section itself was relocated. This should
687 always be the case for GNU/Linux executables and shared libraries.
688 Note that other kind of object files (e.g. those added via
689 add-symbol-files) will currently never end up here anyway, as this
690 function accesses *target* sections only; only the main exec and
691 shared libraries are ever added to the target. */
696 res
= bfd_get_section_contents (s
->bfd
, s
->the_bfd_section
,
697 &buf
, addr
- s
->addr
, 8);
699 return extract_unsigned_integer (buf
, 8, byte_order
)
700 - bfd_section_vma (s
->bfd
, s
->the_bfd_section
) + s
->addr
;
706 /* Wrappers to handle Linux-only registers. */
709 ppc_linux_supply_gregset (const struct regset
*regset
,
710 struct regcache
*regcache
,
711 int regnum
, const void *gregs
, size_t len
)
713 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
715 ppc_supply_gregset (regset
, regcache
, regnum
, gregs
, len
);
717 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
719 /* "orig_r3" is stored 2 slots after "pc". */
720 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
721 ppc_supply_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
722 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
725 /* "trap" is stored 8 slots after "pc". */
726 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
727 ppc_supply_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
728 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
734 ppc_linux_collect_gregset (const struct regset
*regset
,
735 const struct regcache
*regcache
,
736 int regnum
, void *gregs
, size_t len
)
738 const struct ppc_reg_offsets
*offsets
= regset
->descr
;
740 /* Clear areas in the linux gregset not written elsewhere. */
742 memset (gregs
, 0, len
);
744 ppc_collect_gregset (regset
, regcache
, regnum
, gregs
, len
);
746 if (ppc_linux_trap_reg_p (get_regcache_arch (regcache
)))
748 /* "orig_r3" is stored 2 slots after "pc". */
749 if (regnum
== -1 || regnum
== PPC_ORIG_R3_REGNUM
)
750 ppc_collect_reg (regcache
, PPC_ORIG_R3_REGNUM
, gregs
,
751 offsets
->pc_offset
+ 2 * offsets
->gpr_size
,
754 /* "trap" is stored 8 slots after "pc". */
755 if (regnum
== -1 || regnum
== PPC_TRAP_REGNUM
)
756 ppc_collect_reg (regcache
, PPC_TRAP_REGNUM
, gregs
,
757 offsets
->pc_offset
+ 8 * offsets
->gpr_size
,
762 /* Regset descriptions. */
763 static const struct ppc_reg_offsets ppc32_linux_reg_offsets
=
765 /* General-purpose registers. */
766 /* .r0_offset = */ 0,
769 /* .pc_offset = */ 128,
770 /* .ps_offset = */ 132,
771 /* .cr_offset = */ 152,
772 /* .lr_offset = */ 144,
773 /* .ctr_offset = */ 140,
774 /* .xer_offset = */ 148,
775 /* .mq_offset = */ 156,
777 /* Floating-point registers. */
778 /* .f0_offset = */ 0,
779 /* .fpscr_offset = */ 256,
780 /* .fpscr_size = */ 8,
782 /* AltiVec registers. */
783 /* .vr0_offset = */ 0,
784 /* .vscr_offset = */ 512 + 12,
785 /* .vrsave_offset = */ 528
788 static const struct ppc_reg_offsets ppc64_linux_reg_offsets
=
790 /* General-purpose registers. */
791 /* .r0_offset = */ 0,
794 /* .pc_offset = */ 256,
795 /* .ps_offset = */ 264,
796 /* .cr_offset = */ 304,
797 /* .lr_offset = */ 288,
798 /* .ctr_offset = */ 280,
799 /* .xer_offset = */ 296,
800 /* .mq_offset = */ 312,
802 /* Floating-point registers. */
803 /* .f0_offset = */ 0,
804 /* .fpscr_offset = */ 256,
805 /* .fpscr_size = */ 8,
807 /* AltiVec registers. */
808 /* .vr0_offset = */ 0,
809 /* .vscr_offset = */ 512 + 12,
810 /* .vrsave_offset = */ 528
813 static const struct regset ppc32_linux_gregset
= {
814 &ppc32_linux_reg_offsets
,
815 ppc_linux_supply_gregset
,
816 ppc_linux_collect_gregset
,
820 static const struct regset ppc64_linux_gregset
= {
821 &ppc64_linux_reg_offsets
,
822 ppc_linux_supply_gregset
,
823 ppc_linux_collect_gregset
,
827 static const struct regset ppc32_linux_fpregset
= {
828 &ppc32_linux_reg_offsets
,
830 ppc_collect_fpregset
,
834 static const struct regset ppc32_linux_vrregset
= {
835 &ppc32_linux_reg_offsets
,
837 ppc_collect_vrregset
,
841 static const struct regset ppc32_linux_vsxregset
= {
842 &ppc32_linux_reg_offsets
,
843 ppc_supply_vsxregset
,
844 ppc_collect_vsxregset
,
848 const struct regset
*
849 ppc_linux_gregset (int wordsize
)
851 return wordsize
== 8 ? &ppc64_linux_gregset
: &ppc32_linux_gregset
;
854 const struct regset
*
855 ppc_linux_fpregset (void)
857 return &ppc32_linux_fpregset
;
860 static const struct regset
*
861 ppc_linux_regset_from_core_section (struct gdbarch
*core_arch
,
862 const char *sect_name
, size_t sect_size
)
864 struct gdbarch_tdep
*tdep
= gdbarch_tdep (core_arch
);
865 if (strcmp (sect_name
, ".reg") == 0)
867 if (tdep
->wordsize
== 4)
868 return &ppc32_linux_gregset
;
870 return &ppc64_linux_gregset
;
872 if (strcmp (sect_name
, ".reg2") == 0)
873 return &ppc32_linux_fpregset
;
874 if (strcmp (sect_name
, ".reg-ppc-vmx") == 0)
875 return &ppc32_linux_vrregset
;
876 if (strcmp (sect_name
, ".reg-ppc-vsx") == 0)
877 return &ppc32_linux_vsxregset
;
882 ppc_linux_sigtramp_cache (struct frame_info
*this_frame
,
883 struct trad_frame_cache
*this_cache
,
884 CORE_ADDR func
, LONGEST offset
,
892 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
893 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
894 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
896 base
= get_frame_register_unsigned (this_frame
,
897 gdbarch_sp_regnum (gdbarch
));
898 if (bias
> 0 && get_frame_pc (this_frame
) != func
)
899 /* See below, some signal trampolines increment the stack as their
900 first instruction, need to compensate for that. */
903 /* Find the address of the register buffer pointer. */
904 regs
= base
+ offset
;
905 /* Use that to find the address of the corresponding register
907 gpregs
= read_memory_unsigned_integer (regs
, tdep
->wordsize
, byte_order
);
908 fpregs
= gpregs
+ 48 * tdep
->wordsize
;
910 /* General purpose. */
911 for (i
= 0; i
< 32; i
++)
913 int regnum
= i
+ tdep
->ppc_gp0_regnum
;
914 trad_frame_set_reg_addr (this_cache
,
915 regnum
, gpregs
+ i
* tdep
->wordsize
);
917 trad_frame_set_reg_addr (this_cache
,
918 gdbarch_pc_regnum (gdbarch
),
919 gpregs
+ 32 * tdep
->wordsize
);
920 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_ctr_regnum
,
921 gpregs
+ 35 * tdep
->wordsize
);
922 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_lr_regnum
,
923 gpregs
+ 36 * tdep
->wordsize
);
924 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_xer_regnum
,
925 gpregs
+ 37 * tdep
->wordsize
);
926 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_cr_regnum
,
927 gpregs
+ 38 * tdep
->wordsize
);
929 if (ppc_linux_trap_reg_p (gdbarch
))
931 trad_frame_set_reg_addr (this_cache
, PPC_ORIG_R3_REGNUM
,
932 gpregs
+ 34 * tdep
->wordsize
);
933 trad_frame_set_reg_addr (this_cache
, PPC_TRAP_REGNUM
,
934 gpregs
+ 40 * tdep
->wordsize
);
937 if (ppc_floating_point_unit_p (gdbarch
))
939 /* Floating point registers. */
940 for (i
= 0; i
< 32; i
++)
942 int regnum
= i
+ gdbarch_fp0_regnum (gdbarch
);
943 trad_frame_set_reg_addr (this_cache
, regnum
,
944 fpregs
+ i
* tdep
->wordsize
);
946 trad_frame_set_reg_addr (this_cache
, tdep
->ppc_fpscr_regnum
,
947 fpregs
+ 32 * tdep
->wordsize
);
949 trad_frame_set_id (this_cache
, frame_id_build (base
, func
));
953 ppc32_linux_sigaction_cache_init (const struct tramp_frame
*self
,
954 struct frame_info
*this_frame
,
955 struct trad_frame_cache
*this_cache
,
958 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
959 0xd0 /* Offset to ucontext_t. */
960 + 0x30 /* Offset to .reg. */,
965 ppc64_linux_sigaction_cache_init (const struct tramp_frame
*self
,
966 struct frame_info
*this_frame
,
967 struct trad_frame_cache
*this_cache
,
970 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
971 0x80 /* Offset to ucontext_t. */
972 + 0xe0 /* Offset to .reg. */,
977 ppc32_linux_sighandler_cache_init (const struct tramp_frame
*self
,
978 struct frame_info
*this_frame
,
979 struct trad_frame_cache
*this_cache
,
982 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
983 0x40 /* Offset to ucontext_t. */
984 + 0x1c /* Offset to .reg. */,
989 ppc64_linux_sighandler_cache_init (const struct tramp_frame
*self
,
990 struct frame_info
*this_frame
,
991 struct trad_frame_cache
*this_cache
,
994 ppc_linux_sigtramp_cache (this_frame
, this_cache
, func
,
995 0x80 /* Offset to struct sigcontext. */
996 + 0x38 /* Offset to .reg. */,
1000 static struct tramp_frame ppc32_linux_sigaction_tramp_frame
= {
1004 { 0x380000ac, -1 }, /* li r0, 172 */
1005 { 0x44000002, -1 }, /* sc */
1006 { TRAMP_SENTINEL_INSN
},
1008 ppc32_linux_sigaction_cache_init
1010 static struct tramp_frame ppc64_linux_sigaction_tramp_frame
= {
1014 { 0x38210080, -1 }, /* addi r1,r1,128 */
1015 { 0x380000ac, -1 }, /* li r0, 172 */
1016 { 0x44000002, -1 }, /* sc */
1017 { TRAMP_SENTINEL_INSN
},
1019 ppc64_linux_sigaction_cache_init
1021 static struct tramp_frame ppc32_linux_sighandler_tramp_frame
= {
1025 { 0x38000077, -1 }, /* li r0,119 */
1026 { 0x44000002, -1 }, /* sc */
1027 { TRAMP_SENTINEL_INSN
},
1029 ppc32_linux_sighandler_cache_init
1031 static struct tramp_frame ppc64_linux_sighandler_tramp_frame
= {
1035 { 0x38210080, -1 }, /* addi r1,r1,128 */
1036 { 0x38000077, -1 }, /* li r0,119 */
1037 { 0x44000002, -1 }, /* sc */
1038 { TRAMP_SENTINEL_INSN
},
1040 ppc64_linux_sighandler_cache_init
1044 /* Address to use for displaced stepping. When debugging a stand-alone
1045 SPU executable, entry_point_address () will point to an SPU local-store
1046 address and is thus not usable as displaced stepping location. We use
1047 the auxiliary vector to determine the PowerPC-side entry point address
1050 static CORE_ADDR ppc_linux_entry_point_addr
= 0;
1053 ppc_linux_inferior_created (struct target_ops
*target
, int from_tty
)
1055 ppc_linux_entry_point_addr
= 0;
1059 ppc_linux_displaced_step_location (struct gdbarch
*gdbarch
)
1061 if (ppc_linux_entry_point_addr
== 0)
1065 /* Determine entry point from target auxiliary vector. */
1066 if (target_auxv_search (¤t_target
, AT_ENTRY
, &addr
) <= 0)
1067 error (_("Cannot find AT_ENTRY auxiliary vector entry."));
1069 /* Make certain that the address points at real code, and not a
1070 function descriptor. */
1071 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
1074 /* Inferior calls also use the entry point as a breakpoint location.
1075 We don't want displaced stepping to interfere with those
1076 breakpoints, so leave space. */
1077 ppc_linux_entry_point_addr
= addr
+ 2 * PPC_INSN_SIZE
;
1080 return ppc_linux_entry_point_addr
;
1084 /* Return 1 if PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM are usable. */
1086 ppc_linux_trap_reg_p (struct gdbarch
*gdbarch
)
1088 /* If we do not have a target description with registers, then
1089 the special registers will not be included in the register set. */
1090 if (!tdesc_has_registers (gdbarch_target_desc (gdbarch
)))
1093 /* If we do, then it is safe to check the size. */
1094 return register_size (gdbarch
, PPC_ORIG_R3_REGNUM
) > 0
1095 && register_size (gdbarch
, PPC_TRAP_REGNUM
) > 0;
1098 /* Return the current system call's number present in the
1099 r0 register. When the function fails, it returns -1. */
1101 ppc_linux_get_syscall_number (struct gdbarch
*gdbarch
,
1104 struct regcache
*regcache
= get_thread_regcache (ptid
);
1105 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1106 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1107 struct cleanup
*cleanbuf
;
1108 /* The content of a register */
1113 /* Make sure we're in a 32- or 64-bit machine */
1114 gdb_assert (tdep
->wordsize
== 4 || tdep
->wordsize
== 8);
1116 buf
= (gdb_byte
*) xmalloc (tdep
->wordsize
* sizeof (gdb_byte
));
1118 cleanbuf
= make_cleanup (xfree
, buf
);
1120 /* Getting the system call number from the register.
1121 When dealing with PowerPC architecture, this information
1122 is stored at 0th register. */
1123 regcache_cooked_read (regcache
, tdep
->ppc_gp0_regnum
, buf
);
1125 ret
= extract_signed_integer (buf
, tdep
->wordsize
, byte_order
);
1126 do_cleanups (cleanbuf
);
1132 ppc_linux_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1134 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1136 regcache_cooked_write_unsigned (regcache
, gdbarch_pc_regnum (gdbarch
), pc
);
1138 /* Set special TRAP register to -1 to prevent the kernel from
1139 messing with the PC we just installed, if we happen to be
1140 within an interrupted system call that the kernel wants to
1143 Note that after we return from the dummy call, the TRAP and
1144 ORIG_R3 registers will be automatically restored, and the
1145 kernel continues to restart the system call at this point. */
1146 if (ppc_linux_trap_reg_p (gdbarch
))
1147 regcache_cooked_write_unsigned (regcache
, PPC_TRAP_REGNUM
, -1);
1151 ppc_linux_spu_section (bfd
*abfd
, asection
*asect
, void *user_data
)
1153 return strncmp (bfd_section_name (abfd
, asect
), "SPU/", 4) == 0;
1156 static const struct target_desc
*
1157 ppc_linux_core_read_description (struct gdbarch
*gdbarch
,
1158 struct target_ops
*target
,
1161 asection
*cell
= bfd_sections_find_if (abfd
, ppc_linux_spu_section
, NULL
);
1162 asection
*altivec
= bfd_get_section_by_name (abfd
, ".reg-ppc-vmx");
1163 asection
*vsx
= bfd_get_section_by_name (abfd
, ".reg-ppc-vsx");
1164 asection
*section
= bfd_get_section_by_name (abfd
, ".reg");
1168 switch (bfd_section_size (abfd
, section
))
1172 return tdesc_powerpc_cell32l
;
1174 return tdesc_powerpc_vsx32l
;
1176 return tdesc_powerpc_altivec32l
;
1178 return tdesc_powerpc_32l
;
1182 return tdesc_powerpc_cell64l
;
1184 return tdesc_powerpc_vsx64l
;
1186 return tdesc_powerpc_altivec64l
;
1188 return tdesc_powerpc_64l
;
1196 /* Cell/B.E. active SPE context tracking support. */
1198 static struct objfile
*spe_context_objfile
= NULL
;
1199 static CORE_ADDR spe_context_lm_addr
= 0;
1200 static CORE_ADDR spe_context_offset
= 0;
1202 static ptid_t spe_context_cache_ptid
;
1203 static CORE_ADDR spe_context_cache_address
;
1205 /* Hook into inferior_created, solib_loaded, and solib_unloaded observers
1206 to track whether we've loaded a version of libspe2 (as static or dynamic
1207 library) that provides the __spe_current_active_context variable. */
1209 ppc_linux_spe_context_lookup (struct objfile
*objfile
)
1211 struct minimal_symbol
*sym
;
1215 spe_context_objfile
= NULL
;
1216 spe_context_lm_addr
= 0;
1217 spe_context_offset
= 0;
1218 spe_context_cache_ptid
= minus_one_ptid
;
1219 spe_context_cache_address
= 0;
1223 sym
= lookup_minimal_symbol ("__spe_current_active_context", NULL
, objfile
);
1226 spe_context_objfile
= objfile
;
1227 spe_context_lm_addr
= svr4_fetch_objfile_link_map (objfile
);
1228 spe_context_offset
= SYMBOL_VALUE_ADDRESS (sym
);
1229 spe_context_cache_ptid
= minus_one_ptid
;
1230 spe_context_cache_address
= 0;
1236 ppc_linux_spe_context_inferior_created (struct target_ops
*t
, int from_tty
)
1238 struct objfile
*objfile
;
1240 ppc_linux_spe_context_lookup (NULL
);
1241 ALL_OBJFILES (objfile
)
1242 ppc_linux_spe_context_lookup (objfile
);
1246 ppc_linux_spe_context_solib_loaded (struct so_list
*so
)
1248 if (strstr (so
->so_original_name
, "/libspe") != NULL
)
1250 solib_read_symbols (so
, 0);
1251 ppc_linux_spe_context_lookup (so
->objfile
);
1256 ppc_linux_spe_context_solib_unloaded (struct so_list
*so
)
1258 if (so
->objfile
== spe_context_objfile
)
1259 ppc_linux_spe_context_lookup (NULL
);
1262 /* Retrieve contents of the N'th element in the current thread's
1263 linked SPE context list into ID and NPC. Return the address of
1264 said context element, or 0 if not found. */
1266 ppc_linux_spe_context (int wordsize
, enum bfd_endian byte_order
,
1267 int n
, int *id
, unsigned int *npc
)
1269 CORE_ADDR spe_context
= 0;
1273 /* Quick exit if we have not found __spe_current_active_context. */
1274 if (!spe_context_objfile
)
1277 /* Look up cached address of thread-local variable. */
1278 if (!ptid_equal (spe_context_cache_ptid
, inferior_ptid
))
1280 struct target_ops
*target
= ¤t_target
;
1281 volatile struct gdb_exception ex
;
1283 while (target
&& !target
->to_get_thread_local_address
)
1284 target
= find_target_beneath (target
);
1288 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1290 /* We do not call target_translate_tls_address here, because
1291 svr4_fetch_objfile_link_map may invalidate the frame chain,
1292 which must not do while inside a frame sniffer.
1294 Instead, we have cached the lm_addr value, and use that to
1295 directly call the target's to_get_thread_local_address. */
1296 spe_context_cache_address
1297 = target
->to_get_thread_local_address (target
, inferior_ptid
,
1298 spe_context_lm_addr
,
1299 spe_context_offset
);
1300 spe_context_cache_ptid
= inferior_ptid
;
1307 /* Read variable value. */
1308 if (target_read_memory (spe_context_cache_address
, buf
, wordsize
) == 0)
1309 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1311 /* Cyle through to N'th linked list element. */
1312 for (i
= 0; i
< n
&& spe_context
; i
++)
1313 if (target_read_memory (spe_context
+ align_up (12, wordsize
),
1314 buf
, wordsize
) == 0)
1315 spe_context
= extract_unsigned_integer (buf
, wordsize
, byte_order
);
1319 /* Read current context. */
1321 && target_read_memory (spe_context
, buf
, 12) != 0)
1324 /* Extract data elements. */
1328 *id
= extract_signed_integer (buf
, 4, byte_order
);
1330 *npc
= extract_unsigned_integer (buf
+ 4, 4, byte_order
);
1337 /* Cell/B.E. cross-architecture unwinder support. */
1339 struct ppu2spu_cache
1341 struct frame_id frame_id
;
1342 struct regcache
*regcache
;
1345 static struct gdbarch
*
1346 ppu2spu_prev_arch (struct frame_info
*this_frame
, void **this_cache
)
1348 struct ppu2spu_cache
*cache
= *this_cache
;
1349 return get_regcache_arch (cache
->regcache
);
1353 ppu2spu_this_id (struct frame_info
*this_frame
,
1354 void **this_cache
, struct frame_id
*this_id
)
1356 struct ppu2spu_cache
*cache
= *this_cache
;
1357 *this_id
= cache
->frame_id
;
1360 static struct value
*
1361 ppu2spu_prev_register (struct frame_info
*this_frame
,
1362 void **this_cache
, int regnum
)
1364 struct ppu2spu_cache
*cache
= *this_cache
;
1365 struct gdbarch
*gdbarch
= get_regcache_arch (cache
->regcache
);
1368 buf
= alloca (register_size (gdbarch
, regnum
));
1370 if (regnum
< gdbarch_num_regs (gdbarch
))
1371 regcache_raw_read (cache
->regcache
, regnum
, buf
);
1373 gdbarch_pseudo_register_read (gdbarch
, cache
->regcache
, regnum
, buf
);
1375 return frame_unwind_got_bytes (this_frame
, regnum
, buf
);
1380 struct gdbarch
*gdbarch
;
1383 gdb_byte gprs
[128*16];
1387 ppu2spu_unwind_register (void *src
, int regnum
, gdb_byte
*buf
)
1389 struct ppu2spu_data
*data
= src
;
1390 enum bfd_endian byte_order
= gdbarch_byte_order (data
->gdbarch
);
1392 if (regnum
>= 0 && regnum
< SPU_NUM_GPRS
)
1393 memcpy (buf
, data
->gprs
+ 16*regnum
, 16);
1394 else if (regnum
== SPU_ID_REGNUM
)
1395 store_unsigned_integer (buf
, 4, byte_order
, data
->id
);
1396 else if (regnum
== SPU_PC_REGNUM
)
1397 store_unsigned_integer (buf
, 4, byte_order
, data
->npc
);
1399 return REG_UNAVAILABLE
;
1405 ppu2spu_sniffer (const struct frame_unwind
*self
,
1406 struct frame_info
*this_frame
, void **this_prologue_cache
)
1408 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
1409 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1411 struct ppu2spu_data data
;
1412 struct frame_info
*fi
;
1413 CORE_ADDR base
, func
, backchain
, spe_context
;
1417 /* Count the number of SPU contexts already in the frame chain. */
1418 for (fi
= get_next_frame (this_frame
); fi
; fi
= get_next_frame (fi
))
1419 if (get_frame_type (fi
) == ARCH_FRAME
1420 && gdbarch_bfd_arch_info (get_frame_arch (fi
))->arch
== bfd_arch_spu
)
1423 base
= get_frame_sp (this_frame
);
1424 func
= get_frame_pc (this_frame
);
1425 if (target_read_memory (base
, buf
, tdep
->wordsize
))
1427 backchain
= extract_unsigned_integer (buf
, tdep
->wordsize
, byte_order
);
1429 spe_context
= ppc_linux_spe_context (tdep
->wordsize
, byte_order
,
1430 n
, &data
.id
, &data
.npc
);
1431 if (spe_context
&& base
<= spe_context
&& spe_context
< backchain
)
1435 /* Find gdbarch for SPU. */
1436 struct gdbarch_info info
;
1437 gdbarch_info_init (&info
);
1438 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
);
1439 info
.byte_order
= BFD_ENDIAN_BIG
;
1440 info
.osabi
= GDB_OSABI_LINUX
;
1441 info
.tdep_info
= (void *) &data
.id
;
1442 data
.gdbarch
= gdbarch_find_by_info (info
);
1446 xsnprintf (annex
, sizeof annex
, "%d/regs", data
.id
);
1447 if (target_read (¤t_target
, TARGET_OBJECT_SPU
, annex
,
1448 data
.gprs
, 0, sizeof data
.gprs
)
1449 == sizeof data
.gprs
)
1451 struct ppu2spu_cache
*cache
1452 = FRAME_OBSTACK_CALLOC (1, struct ppu2spu_cache
);
1454 struct address_space
*aspace
= get_frame_address_space (this_frame
);
1455 struct regcache
*regcache
= regcache_xmalloc (data
.gdbarch
, aspace
);
1456 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (regcache
);
1457 regcache_save (regcache
, ppu2spu_unwind_register
, &data
);
1458 discard_cleanups (cleanups
);
1460 cache
->frame_id
= frame_id_build (base
, func
);
1461 cache
->regcache
= regcache
;
1462 *this_prologue_cache
= cache
;
1471 ppu2spu_dealloc_cache (struct frame_info
*self
, void *this_cache
)
1473 struct ppu2spu_cache
*cache
= this_cache
;
1474 regcache_xfree (cache
->regcache
);
1477 static const struct frame_unwind ppu2spu_unwind
= {
1479 default_frame_unwind_stop_reason
,
1481 ppu2spu_prev_register
,
1484 ppu2spu_dealloc_cache
,
1490 ppc_linux_init_abi (struct gdbarch_info info
,
1491 struct gdbarch
*gdbarch
)
1493 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1494 struct tdesc_arch_data
*tdesc_data
= (void *) info
.tdep_info
;
1496 linux_init_abi (info
, gdbarch
);
1498 /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where
1499 128-bit, they are IBM long double, not IEEE quad long double as
1500 in the System V ABI PowerPC Processor Supplement. We can safely
1501 let them default to 128-bit, since the debug info will give the
1502 size of type actually used in each case. */
1503 set_gdbarch_long_double_bit (gdbarch
, 16 * TARGET_CHAR_BIT
);
1504 set_gdbarch_long_double_format (gdbarch
, floatformats_ibm_long_double
);
1506 /* Handle inferior calls during interrupted system calls. */
1507 set_gdbarch_write_pc (gdbarch
, ppc_linux_write_pc
);
1509 /* Get the syscall number from the arch's register. */
1510 set_gdbarch_get_syscall_number (gdbarch
, ppc_linux_get_syscall_number
);
1512 if (tdep
->wordsize
== 4)
1514 /* Until November 2001, gcc did not comply with the 32 bit SysV
1515 R4 ABI requirement that structures less than or equal to 8
1516 bytes should be returned in registers. Instead GCC was using
1517 the AIX/PowerOpen ABI - everything returned in memory
1518 (well ignoring vectors that is). When this was corrected, it
1519 wasn't fixed for GNU/Linux native platform. Use the
1520 PowerOpen struct convention. */
1521 set_gdbarch_return_value (gdbarch
, ppc_linux_return_value
);
1523 set_gdbarch_memory_remove_breakpoint (gdbarch
,
1524 ppc_linux_memory_remove_breakpoint
);
1526 /* Shared library handling. */
1527 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1528 set_solib_svr4_fetch_link_map_offsets
1529 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1531 /* Setting the correct XML syscall filename. */
1532 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_PPC
);
1535 tramp_frame_prepend_unwinder (gdbarch
,
1536 &ppc32_linux_sigaction_tramp_frame
);
1537 tramp_frame_prepend_unwinder (gdbarch
,
1538 &ppc32_linux_sighandler_tramp_frame
);
1540 /* BFD target for core files. */
1541 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1542 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpcle");
1544 set_gdbarch_gcore_bfd_target (gdbarch
, "elf32-powerpc");
1546 /* Supported register sections. */
1547 if (tdesc_find_feature (info
.target_desc
,
1548 "org.gnu.gdb.power.vsx"))
1549 set_gdbarch_core_regset_sections (gdbarch
,
1550 ppc_linux_vsx_regset_sections
);
1551 else if (tdesc_find_feature (info
.target_desc
,
1552 "org.gnu.gdb.power.altivec"))
1553 set_gdbarch_core_regset_sections (gdbarch
,
1554 ppc_linux_vmx_regset_sections
);
1556 set_gdbarch_core_regset_sections (gdbarch
,
1557 ppc_linux_fp_regset_sections
);
1560 if (tdep
->wordsize
== 8)
1562 /* Handle PPC GNU/Linux 64-bit function pointers (which are really
1563 function descriptors). */
1564 set_gdbarch_convert_from_func_ptr_addr
1565 (gdbarch
, ppc64_linux_convert_from_func_ptr_addr
);
1567 /* Shared library handling. */
1568 set_gdbarch_skip_trampoline_code (gdbarch
, ppc64_skip_trampoline_code
);
1569 set_solib_svr4_fetch_link_map_offsets
1570 (gdbarch
, svr4_lp64_fetch_link_map_offsets
);
1572 /* Setting the correct XML syscall filename. */
1573 set_xml_syscall_file_name (XML_SYSCALL_FILENAME_PPC64
);
1576 tramp_frame_prepend_unwinder (gdbarch
,
1577 &ppc64_linux_sigaction_tramp_frame
);
1578 tramp_frame_prepend_unwinder (gdbarch
,
1579 &ppc64_linux_sighandler_tramp_frame
);
1581 /* BFD target for core files. */
1582 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_LITTLE
)
1583 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpcle");
1585 set_gdbarch_gcore_bfd_target (gdbarch
, "elf64-powerpc");
1587 /* Supported register sections. */
1588 if (tdesc_find_feature (info
.target_desc
,
1589 "org.gnu.gdb.power.vsx"))
1590 set_gdbarch_core_regset_sections (gdbarch
,
1591 ppc64_linux_vsx_regset_sections
);
1592 else if (tdesc_find_feature (info
.target_desc
,
1593 "org.gnu.gdb.power.altivec"))
1594 set_gdbarch_core_regset_sections (gdbarch
,
1595 ppc64_linux_vmx_regset_sections
);
1597 set_gdbarch_core_regset_sections (gdbarch
,
1598 ppc64_linux_fp_regset_sections
);
1600 set_gdbarch_regset_from_core_section (gdbarch
,
1601 ppc_linux_regset_from_core_section
);
1602 set_gdbarch_core_read_description (gdbarch
, ppc_linux_core_read_description
);
1604 /* Enable TLS support. */
1605 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1606 svr4_fetch_objfile_link_map
);
1610 const struct tdesc_feature
*feature
;
1612 /* If we have target-described registers, then we can safely
1613 reserve a number for PPC_ORIG_R3_REGNUM and PPC_TRAP_REGNUM
1614 (whether they are described or not). */
1615 gdb_assert (gdbarch_num_regs (gdbarch
) <= PPC_ORIG_R3_REGNUM
);
1616 set_gdbarch_num_regs (gdbarch
, PPC_TRAP_REGNUM
+ 1);
1618 /* If they are present, then assign them to the reserved number. */
1619 feature
= tdesc_find_feature (info
.target_desc
,
1620 "org.gnu.gdb.power.linux");
1621 if (feature
!= NULL
)
1623 tdesc_numbered_register (feature
, tdesc_data
,
1624 PPC_ORIG_R3_REGNUM
, "orig_r3");
1625 tdesc_numbered_register (feature
, tdesc_data
,
1626 PPC_TRAP_REGNUM
, "trap");
1630 /* Enable Cell/B.E. if supported by the target. */
1631 if (tdesc_compatible_p (info
.target_desc
,
1632 bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
)))
1634 /* Cell/B.E. multi-architecture support. */
1635 set_spu_solib_ops (gdbarch
);
1637 /* Cell/B.E. cross-architecture unwinder support. */
1638 frame_unwind_prepend_unwinder (gdbarch
, &ppu2spu_unwind
);
1640 /* The default displaced_step_at_entry_point doesn't work for
1641 SPU stand-alone executables. */
1642 set_gdbarch_displaced_step_location (gdbarch
,
1643 ppc_linux_displaced_step_location
);
1647 /* Provide a prototype to silence -Wmissing-prototypes. */
1648 extern initialize_file_ftype _initialize_ppc_linux_tdep
;
1651 _initialize_ppc_linux_tdep (void)
1653 /* Register for all sub-familes of the POWER/PowerPC: 32-bit and
1654 64-bit PowerPC, and the older rs6k. */
1655 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc
, GDB_OSABI_LINUX
,
1656 ppc_linux_init_abi
);
1657 gdbarch_register_osabi (bfd_arch_powerpc
, bfd_mach_ppc64
, GDB_OSABI_LINUX
,
1658 ppc_linux_init_abi
);
1659 gdbarch_register_osabi (bfd_arch_rs6000
, bfd_mach_rs6k
, GDB_OSABI_LINUX
,
1660 ppc_linux_init_abi
);
1662 /* Attach to inferior_created observer. */
1663 observer_attach_inferior_created (ppc_linux_inferior_created
);
1665 /* Attach to observers to track __spe_current_active_context. */
1666 observer_attach_inferior_created (ppc_linux_spe_context_inferior_created
);
1667 observer_attach_solib_loaded (ppc_linux_spe_context_solib_loaded
);
1668 observer_attach_solib_unloaded (ppc_linux_spe_context_solib_unloaded
);
1670 /* Initialize the Linux target descriptions. */
1671 initialize_tdesc_powerpc_32l ();
1672 initialize_tdesc_powerpc_altivec32l ();
1673 initialize_tdesc_powerpc_cell32l ();
1674 initialize_tdesc_powerpc_vsx32l ();
1675 initialize_tdesc_powerpc_isa205_32l ();
1676 initialize_tdesc_powerpc_isa205_altivec32l ();
1677 initialize_tdesc_powerpc_isa205_vsx32l ();
1678 initialize_tdesc_powerpc_64l ();
1679 initialize_tdesc_powerpc_altivec64l ();
1680 initialize_tdesc_powerpc_cell64l ();
1681 initialize_tdesc_powerpc_vsx64l ();
1682 initialize_tdesc_powerpc_isa205_64l ();
1683 initialize_tdesc_powerpc_isa205_altivec64l ();
1684 initialize_tdesc_powerpc_isa205_vsx64l ();
1685 initialize_tdesc_powerpc_e500l ();